Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AacCodingMode

type AacCodingMode string
const (
	AacCodingModeAdReceiverMix AacCodingMode = "AD_RECEIVER_MIX"
	AacCodingModeCodingMode10  AacCodingMode = "CODING_MODE_1_0"
	AacCodingModeCodingMode11  AacCodingMode = "CODING_MODE_1_1"
	AacCodingModeCodingMode20  AacCodingMode = "CODING_MODE_2_0"
	AacCodingModeCodingMode51  AacCodingMode = "CODING_MODE_5_1"
)

    Enum values for AacCodingMode

    func (AacCodingMode) Values

    func (AacCodingMode) Values() []AacCodingMode

      Values returns all known values for AacCodingMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

      type AacInputType

      type AacInputType string
      const (
      	AacInputTypeBroadcasterMixedAd AacInputType = "BROADCASTER_MIXED_AD"
      	AacInputTypeNormal             AacInputType = "NORMAL"
      )

        Enum values for AacInputType

        func (AacInputType) Values

        func (AacInputType) Values() []AacInputType

          Values returns all known values for AacInputType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

          type AacProfile

          type AacProfile string
          const (
          	AacProfileHev1 AacProfile = "HEV1"
          	AacProfileHev2 AacProfile = "HEV2"
          	AacProfileLc   AacProfile = "LC"
          )

            Enum values for AacProfile

            func (AacProfile) Values

            func (AacProfile) Values() []AacProfile

              Values returns all known values for AacProfile. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

              type AacRateControlMode

              type AacRateControlMode string
              const (
              	AacRateControlModeCbr AacRateControlMode = "CBR"
              	AacRateControlModeVbr AacRateControlMode = "VBR"
              )

                Enum values for AacRateControlMode

                func (AacRateControlMode) Values

                  Values returns all known values for AacRateControlMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                  type AacRawFormat

                  type AacRawFormat string
                  const (
                  	AacRawFormatLatmLoas AacRawFormat = "LATM_LOAS"
                  	AacRawFormatNone     AacRawFormat = "NONE"
                  )

                    Enum values for AacRawFormat

                    func (AacRawFormat) Values

                    func (AacRawFormat) Values() []AacRawFormat

                      Values returns all known values for AacRawFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                      type AacSettings

                      type AacSettings struct {
                      
                      	// Average bitrate in bits/second. Valid values depend on rate control mode and
                      	// profile.
                      	Bitrate float64
                      
                      	// Mono, Stereo, or 5.1 channel layout. Valid values depend on rate control mode
                      	// and profile. The adReceiverMix setting receives a stereo description plus
                      	// control track and emits a mono AAC encode of the description track, with control
                      	// data emitted in the PES header as per ETSI TS 101 154 Annex E.
                      	CodingMode AacCodingMode
                      
                      	// Set to "broadcasterMixedAd" when input contains pre-mixed main audio + AD
                      	// (narration) as a stereo pair. The Audio Type field (audioType) will be set to 3,
                      	// which signals to downstream systems that this stream contains "broadcaster mixed
                      	// AD". Note that the input received by the encoder must contain pre-mixed audio;
                      	// the encoder does not perform the mixing. The values in audioTypeControl and
                      	// audioType (in AudioDescription) are ignored when set to broadcasterMixedAd.
                      	// Leave set to "normal" when input does not contain pre-mixed audio + AD.
                      	InputType AacInputType
                      
                      	// AAC Profile.
                      	Profile AacProfile
                      
                      	// Rate Control Mode.
                      	RateControlMode AacRateControlMode
                      
                      	// Sets LATM / LOAS AAC output for raw containers.
                      	RawFormat AacRawFormat
                      
                      	// Sample rate in Hz. Valid values depend on rate control mode and profile.
                      	SampleRate float64
                      
                      	// Use MPEG-2 AAC audio instead of MPEG-4 AAC audio for raw or MPEG-2 Transport
                      	// Stream containers.
                      	Spec AacSpec
                      
                      	// VBR Quality Level - Only used if rateControlMode is VBR.
                      	VbrQuality AacVbrQuality
                      }

                        Aac Settings

                        type AacSpec

                        type AacSpec string
                        const (
                        	AacSpecMpeg2 AacSpec = "MPEG2"
                        	AacSpecMpeg4 AacSpec = "MPEG4"
                        )

                          Enum values for AacSpec

                          func (AacSpec) Values

                          func (AacSpec) Values() []AacSpec

                            Values returns all known values for AacSpec. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                            type AacVbrQuality

                            type AacVbrQuality string
                            const (
                            	AacVbrQualityHigh       AacVbrQuality = "HIGH"
                            	AacVbrQualityLow        AacVbrQuality = "LOW"
                            	AacVbrQualityMediumHigh AacVbrQuality = "MEDIUM_HIGH"
                            	AacVbrQualityMediumLow  AacVbrQuality = "MEDIUM_LOW"
                            )

                              Enum values for AacVbrQuality

                              func (AacVbrQuality) Values

                              func (AacVbrQuality) Values() []AacVbrQuality

                                Values returns all known values for AacVbrQuality. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                type Ac3BitstreamMode

                                type Ac3BitstreamMode string
                                const (
                                	Ac3BitstreamModeCommentary       Ac3BitstreamMode = "COMMENTARY"
                                	Ac3BitstreamModeCompleteMain     Ac3BitstreamMode = "COMPLETE_MAIN"
                                	Ac3BitstreamModeDialogue         Ac3BitstreamMode = "DIALOGUE"
                                	Ac3BitstreamModeEmergency        Ac3BitstreamMode = "EMERGENCY"
                                	Ac3BitstreamModeHearingImpaired  Ac3BitstreamMode = "HEARING_IMPAIRED"
                                	Ac3BitstreamModeMusicAndEffects  Ac3BitstreamMode = "MUSIC_AND_EFFECTS"
                                	Ac3BitstreamModeVisuallyImpaired Ac3BitstreamMode = "VISUALLY_IMPAIRED"
                                	Ac3BitstreamModeVoiceOver        Ac3BitstreamMode = "VOICE_OVER"
                                )

                                  Enum values for Ac3BitstreamMode

                                  func (Ac3BitstreamMode) Values

                                    Values returns all known values for Ac3BitstreamMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                    type Ac3CodingMode

                                    type Ac3CodingMode string
                                    const (
                                    	Ac3CodingModeCodingMode10    Ac3CodingMode = "CODING_MODE_1_0"
                                    	Ac3CodingModeCodingMode11    Ac3CodingMode = "CODING_MODE_1_1"
                                    	Ac3CodingModeCodingMode20    Ac3CodingMode = "CODING_MODE_2_0"
                                    	Ac3CodingModeCodingMode32Lfe Ac3CodingMode = "CODING_MODE_3_2_LFE"
                                    )

                                      Enum values for Ac3CodingMode

                                      func (Ac3CodingMode) Values

                                      func (Ac3CodingMode) Values() []Ac3CodingMode

                                        Values returns all known values for Ac3CodingMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                        type Ac3DrcProfile

                                        type Ac3DrcProfile string
                                        const (
                                        	Ac3DrcProfileFilmStandard Ac3DrcProfile = "FILM_STANDARD"
                                        	Ac3DrcProfileNone         Ac3DrcProfile = "NONE"
                                        )

                                          Enum values for Ac3DrcProfile

                                          func (Ac3DrcProfile) Values

                                          func (Ac3DrcProfile) Values() []Ac3DrcProfile

                                            Values returns all known values for Ac3DrcProfile. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                            type Ac3LfeFilter

                                            type Ac3LfeFilter string
                                            const (
                                            	Ac3LfeFilterDisabled Ac3LfeFilter = "DISABLED"
                                            	Ac3LfeFilterEnabled  Ac3LfeFilter = "ENABLED"
                                            )

                                              Enum values for Ac3LfeFilter

                                              func (Ac3LfeFilter) Values

                                              func (Ac3LfeFilter) Values() []Ac3LfeFilter

                                                Values returns all known values for Ac3LfeFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                type Ac3MetadataControl

                                                type Ac3MetadataControl string
                                                const (
                                                	Ac3MetadataControlFollowInput   Ac3MetadataControl = "FOLLOW_INPUT"
                                                	Ac3MetadataControlUseConfigured Ac3MetadataControl = "USE_CONFIGURED"
                                                )

                                                  Enum values for Ac3MetadataControl

                                                  func (Ac3MetadataControl) Values

                                                    Values returns all known values for Ac3MetadataControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type Ac3Settings

                                                    type Ac3Settings struct {
                                                    
                                                    	// Average bitrate in bits/second. Valid bitrates depend on the coding mode.
                                                    	Bitrate float64
                                                    
                                                    	// Specifies the bitstream mode (bsmod) for the emitted AC-3 stream. See ATSC
                                                    	// A/52-2012 for background on these values.
                                                    	BitstreamMode Ac3BitstreamMode
                                                    
                                                    	// Dolby Digital coding mode. Determines number of channels.
                                                    	CodingMode Ac3CodingMode
                                                    
                                                    	// Sets the dialnorm for the output. If excluded and input audio is Dolby Digital,
                                                    	// dialnorm will be passed through.
                                                    	Dialnorm int32
                                                    
                                                    	// If set to filmStandard, adds dynamic range compression signaling to the output
                                                    	// bitstream as defined in the Dolby Digital specification.
                                                    	DrcProfile Ac3DrcProfile
                                                    
                                                    	// When set to enabled, applies a 120Hz lowpass filter to the LFE channel prior to
                                                    	// encoding. Only valid in codingMode32Lfe mode.
                                                    	LfeFilter Ac3LfeFilter
                                                    
                                                    	// When set to "followInput", encoder metadata will be sourced from the DD, DD+, or
                                                    	// DolbyE decoder that supplied this audio data. If audio was not supplied from one
                                                    	// of these streams, then the static metadata settings will be used.
                                                    	MetadataControl Ac3MetadataControl
                                                    }

                                                      Ac3 Settings

                                                      type AcceptHeader

                                                      type AcceptHeader string
                                                      const (
                                                      	AcceptHeaderImageJpeg AcceptHeader = "image/jpeg"
                                                      )

                                                        Enum values for AcceptHeader

                                                        func (AcceptHeader) Values

                                                        func (AcceptHeader) Values() []AcceptHeader

                                                          Values returns all known values for AcceptHeader. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type AfdSignaling

                                                          type AfdSignaling string
                                                          const (
                                                          	AfdSignalingAuto  AfdSignaling = "AUTO"
                                                          	AfdSignalingFixed AfdSignaling = "FIXED"
                                                          	AfdSignalingNone  AfdSignaling = "NONE"
                                                          )

                                                            Enum values for AfdSignaling

                                                            func (AfdSignaling) Values

                                                            func (AfdSignaling) Values() []AfdSignaling

                                                              Values returns all known values for AfdSignaling. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                              type AncillarySourceSettings

                                                              type AncillarySourceSettings struct {
                                                              
                                                              	// Specifies the number (1 to 4) of the captions channel you want to extract from
                                                              	// the ancillary captions. If you plan to convert the ancillary captions to another
                                                              	// format, complete this field. If you plan to choose Embedded as the captions
                                                              	// destination in the output (to pass through all the channels in the ancillary
                                                              	// captions), leave this field blank because MediaLive ignores the field.
                                                              	SourceAncillaryChannelNumber int32
                                                              }

                                                                Ancillary Source Settings

                                                                type ArchiveContainerSettings

                                                                type ArchiveContainerSettings struct {
                                                                
                                                                	// M2ts Settings
                                                                	M2tsSettings *M2tsSettings
                                                                
                                                                	// Raw Settings
                                                                	RawSettings *RawSettings
                                                                }

                                                                  Archive Container Settings

                                                                  type ArchiveGroupSettings

                                                                  type ArchiveGroupSettings struct {
                                                                  
                                                                  	// A directory and base filename where archive files should be written.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Destination *OutputLocationRef
                                                                  
                                                                  	// Number of seconds to write to archive file before closing and starting a new
                                                                  	// one.
                                                                  	RolloverInterval int32
                                                                  }

                                                                    Archive Group Settings

                                                                    type ArchiveOutputSettings

                                                                    type ArchiveOutputSettings struct {
                                                                    
                                                                    	// Settings specific to the container type of the file.
                                                                    	//
                                                                    	// This member is required.
                                                                    	ContainerSettings *ArchiveContainerSettings
                                                                    
                                                                    	// Output file extension. If excluded, this will be auto-selected from the
                                                                    	// container type.
                                                                    	Extension *string
                                                                    
                                                                    	// String concatenated to the end of the destination filename. Required for
                                                                    	// multiple outputs of the same type.
                                                                    	NameModifier *string
                                                                    }

                                                                      Archive Output Settings

                                                                      type AribDestinationSettings

                                                                      type AribDestinationSettings struct {
                                                                      }

                                                                        Arib Destination Settings

                                                                        type AribSourceSettings

                                                                        type AribSourceSettings struct {
                                                                        }

                                                                          Arib Source Settings

                                                                          type AudioChannelMapping

                                                                          type AudioChannelMapping struct {
                                                                          
                                                                          	// Indices and gain values for each input channel that should be remixed into this
                                                                          	// output channel.
                                                                          	//
                                                                          	// This member is required.
                                                                          	InputChannelLevels []InputChannelLevel
                                                                          
                                                                          	// The index of the output channel being produced.
                                                                          	//
                                                                          	// This member is required.
                                                                          	OutputChannel int32
                                                                          }

                                                                            Audio Channel Mapping

                                                                            type AudioCodecSettings

                                                                            type AudioCodecSettings struct {
                                                                            
                                                                            	// Aac Settings
                                                                            	AacSettings *AacSettings
                                                                            
                                                                            	// Ac3 Settings
                                                                            	Ac3Settings *Ac3Settings
                                                                            
                                                                            	// Eac3 Settings
                                                                            	Eac3Settings *Eac3Settings
                                                                            
                                                                            	// Mp2 Settings
                                                                            	Mp2Settings *Mp2Settings
                                                                            
                                                                            	// Pass Through Settings
                                                                            	PassThroughSettings *PassThroughSettings
                                                                            
                                                                            	// Wav Settings
                                                                            	WavSettings *WavSettings
                                                                            }

                                                                              Audio Codec Settings

                                                                              type AudioDescription

                                                                              type AudioDescription struct {
                                                                              
                                                                              	// The name of the AudioSelector used as the source for this AudioDescription.
                                                                              	//
                                                                              	// This member is required.
                                                                              	AudioSelectorName *string
                                                                              
                                                                              	// The name of this AudioDescription. Outputs will use this name to uniquely
                                                                              	// identify this AudioDescription. Description names should be unique within this
                                                                              	// Live Event.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Name *string
                                                                              
                                                                              	// Advanced audio normalization settings.
                                                                              	AudioNormalizationSettings *AudioNormalizationSettings
                                                                              
                                                                              	// Applies only if audioTypeControl is useConfigured. The values for audioType are
                                                                              	// defined in ISO-IEC 13818-1.
                                                                              	AudioType AudioType
                                                                              
                                                                              	// Determines how audio type is determined. followInput: If the input contains an
                                                                              	// ISO 639 audioType, then that value is passed through to the output. If the input
                                                                              	// contains no ISO 639 audioType, the value in Audio Type is included in the
                                                                              	// output. useConfigured: The value in Audio Type is included in the output. Note
                                                                              	// that this field and audioType are both ignored if inputType is
                                                                              	// broadcasterMixedAd.
                                                                              	AudioTypeControl AudioDescriptionAudioTypeControl
                                                                              
                                                                              	// Audio codec settings.
                                                                              	CodecSettings *AudioCodecSettings
                                                                              
                                                                              	// RFC 5646 language code representing the language of the audio output track. Only
                                                                              	// used if languageControlMode is useConfigured, or there is no ISO 639 language
                                                                              	// code specified in the input.
                                                                              	LanguageCode *string
                                                                              
                                                                              	// Choosing followInput will cause the ISO 639 language code of the output to
                                                                              	// follow the ISO 639 language code of the input. The languageCode will be used
                                                                              	// when useConfigured is set, or when followInput is selected but there is no ISO
                                                                              	// 639 language code specified by the input.
                                                                              	LanguageCodeControl AudioDescriptionLanguageCodeControl
                                                                              
                                                                              	// Settings that control how input audio channels are remixed into the output audio
                                                                              	// channels.
                                                                              	RemixSettings *RemixSettings
                                                                              
                                                                              	// Used for MS Smooth and Apple HLS outputs. Indicates the name displayed by the
                                                                              	// player (eg. English, or Director Commentary).
                                                                              	StreamName *string
                                                                              }

                                                                                Audio Description

                                                                                type AudioDescriptionAudioTypeControl

                                                                                type AudioDescriptionAudioTypeControl string
                                                                                const (
                                                                                	AudioDescriptionAudioTypeControlFollowInput   AudioDescriptionAudioTypeControl = "FOLLOW_INPUT"
                                                                                	AudioDescriptionAudioTypeControlUseConfigured AudioDescriptionAudioTypeControl = "USE_CONFIGURED"
                                                                                )

                                                                                  Enum values for AudioDescriptionAudioTypeControl

                                                                                  func (AudioDescriptionAudioTypeControl) Values

                                                                                    Values returns all known values for AudioDescriptionAudioTypeControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                    type AudioDescriptionLanguageCodeControl

                                                                                    type AudioDescriptionLanguageCodeControl string
                                                                                    const (
                                                                                    	AudioDescriptionLanguageCodeControlFollowInput   AudioDescriptionLanguageCodeControl = "FOLLOW_INPUT"
                                                                                    	AudioDescriptionLanguageCodeControlUseConfigured AudioDescriptionLanguageCodeControl = "USE_CONFIGURED"
                                                                                    )

                                                                                      Enum values for AudioDescriptionLanguageCodeControl

                                                                                      func (AudioDescriptionLanguageCodeControl) Values

                                                                                        Values returns all known values for AudioDescriptionLanguageCodeControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                        type AudioLanguageSelection

                                                                                        type AudioLanguageSelection struct {
                                                                                        
                                                                                        	// Selects a specific three-letter language code from within an audio source.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	LanguageCode *string
                                                                                        
                                                                                        	// When set to "strict", the transport stream demux strictly identifies audio
                                                                                        	// streams by their language descriptor. If a PMT update occurs such that an audio
                                                                                        	// stream matching the initially selected language is no longer present then mute
                                                                                        	// will be encoded until the language returns. If "loose", then on a PMT update the
                                                                                        	// demux will choose another audio stream in the program with the same stream type
                                                                                        	// if it can't find one with the same language.
                                                                                        	LanguageSelectionPolicy AudioLanguageSelectionPolicy
                                                                                        }

                                                                                          Audio Language Selection

                                                                                          type AudioLanguageSelectionPolicy

                                                                                          type AudioLanguageSelectionPolicy string
                                                                                          const (
                                                                                          	AudioLanguageSelectionPolicyLoose  AudioLanguageSelectionPolicy = "LOOSE"
                                                                                          	AudioLanguageSelectionPolicyStrict AudioLanguageSelectionPolicy = "STRICT"
                                                                                          )

                                                                                            Enum values for AudioLanguageSelectionPolicy

                                                                                            func (AudioLanguageSelectionPolicy) Values

                                                                                              Values returns all known values for AudioLanguageSelectionPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                              type AudioNormalizationAlgorithm

                                                                                              type AudioNormalizationAlgorithm string
                                                                                              const (
                                                                                              	AudioNormalizationAlgorithmItu17701 AudioNormalizationAlgorithm = "ITU_1770_1"
                                                                                              	AudioNormalizationAlgorithmItu17702 AudioNormalizationAlgorithm = "ITU_1770_2"
                                                                                              )

                                                                                                Enum values for AudioNormalizationAlgorithm

                                                                                                func (AudioNormalizationAlgorithm) Values

                                                                                                  Values returns all known values for AudioNormalizationAlgorithm. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                  type AudioNormalizationAlgorithmControl

                                                                                                  type AudioNormalizationAlgorithmControl string
                                                                                                  const (
                                                                                                  	AudioNormalizationAlgorithmControlCorrectAudio AudioNormalizationAlgorithmControl = "CORRECT_AUDIO"
                                                                                                  )

                                                                                                    Enum values for AudioNormalizationAlgorithmControl

                                                                                                    func (AudioNormalizationAlgorithmControl) Values

                                                                                                      Values returns all known values for AudioNormalizationAlgorithmControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                      type AudioNormalizationSettings

                                                                                                      type AudioNormalizationSettings struct {
                                                                                                      
                                                                                                      	// Audio normalization algorithm to use. itu17701 conforms to the CALM Act
                                                                                                      	// specification, itu17702 conforms to the EBU R-128 specification.
                                                                                                      	Algorithm AudioNormalizationAlgorithm
                                                                                                      
                                                                                                      	// When set to correctAudio the output audio is corrected using the chosen
                                                                                                      	// algorithm. If set to measureOnly, the audio will be measured but not adjusted.
                                                                                                      	AlgorithmControl AudioNormalizationAlgorithmControl
                                                                                                      
                                                                                                      	// Target LKFS(loudness) to adjust volume to. If no value is entered, a default
                                                                                                      	// value will be used according to the chosen algorithm. The CALM Act (1770-1)
                                                                                                      	// recommends a target of -24 LKFS. The EBU R-128 specification (1770-2) recommends
                                                                                                      	// a target of -23 LKFS.
                                                                                                      	TargetLkfs float64
                                                                                                      }

                                                                                                        Audio Normalization Settings

                                                                                                        type AudioOnlyHlsSegmentType

                                                                                                        type AudioOnlyHlsSegmentType string
                                                                                                        const (
                                                                                                        	AudioOnlyHlsSegmentTypeAac  AudioOnlyHlsSegmentType = "AAC"
                                                                                                        	AudioOnlyHlsSegmentTypeFmp4 AudioOnlyHlsSegmentType = "FMP4"
                                                                                                        )

                                                                                                          Enum values for AudioOnlyHlsSegmentType

                                                                                                          func (AudioOnlyHlsSegmentType) Values

                                                                                                            Values returns all known values for AudioOnlyHlsSegmentType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                            type AudioOnlyHlsSettings

                                                                                                            type AudioOnlyHlsSettings struct {
                                                                                                            
                                                                                                            	// Specifies the group to which the audio Rendition belongs.
                                                                                                            	AudioGroupId *string
                                                                                                            
                                                                                                            	// Optional. Specifies the .jpg or .png image to use as the cover art for an
                                                                                                            	// audio-only output. We recommend a low bit-size file because the image increases
                                                                                                            	// the output audio bandwidth. The image is attached to the audio as an ID3 tag,
                                                                                                            	// frame type APIC, picture type 0x10, as per the "ID3 tag version 2.4.0 - Native
                                                                                                            	// Frames" standard.
                                                                                                            	AudioOnlyImage *InputLocation
                                                                                                            
                                                                                                            	// Four types of audio-only tracks are supported: Audio-Only Variant Stream The
                                                                                                            	// client can play back this audio-only stream instead of video in low-bandwidth
                                                                                                            	// scenarios. Represented as an EXT-X-STREAM-INF in the HLS manifest. Alternate
                                                                                                            	// Audio, Auto Select, Default Alternate rendition that the client should try to
                                                                                                            	// play back by default. Represented as an EXT-X-MEDIA in the HLS manifest with
                                                                                                            	// DEFAULT=YES, AUTOSELECT=YES Alternate Audio, Auto Select, Not Default Alternate
                                                                                                            	// rendition that the client may try to play back by default. Represented as an
                                                                                                            	// EXT-X-MEDIA in the HLS manifest with DEFAULT=NO, AUTOSELECT=YES Alternate Audio,
                                                                                                            	// not Auto Select Alternate rendition that the client will not try to play back by
                                                                                                            	// default. Represented as an EXT-X-MEDIA in the HLS manifest with DEFAULT=NO,
                                                                                                            	// AUTOSELECT=NO
                                                                                                            	AudioTrackType AudioOnlyHlsTrackType
                                                                                                            
                                                                                                            	// Specifies the segment type.
                                                                                                            	SegmentType AudioOnlyHlsSegmentType
                                                                                                            }

                                                                                                              Audio Only Hls Settings

                                                                                                              type AudioOnlyHlsTrackType

                                                                                                              type AudioOnlyHlsTrackType string
                                                                                                              const (
                                                                                                              	AudioOnlyHlsTrackTypeAlternateAudioAutoSelect        AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_AUTO_SELECT"
                                                                                                              	AudioOnlyHlsTrackTypeAlternateAudioAutoSelectDefault AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT"
                                                                                                              	AudioOnlyHlsTrackTypeAlternateAudioNotAutoSelect     AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_NOT_AUTO_SELECT"
                                                                                                              	AudioOnlyHlsTrackTypeAudioOnlyVariantStream          AudioOnlyHlsTrackType = "AUDIO_ONLY_VARIANT_STREAM"
                                                                                                              )

                                                                                                                Enum values for AudioOnlyHlsTrackType

                                                                                                                func (AudioOnlyHlsTrackType) Values

                                                                                                                  Values returns all known values for AudioOnlyHlsTrackType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                  type AudioPidSelection

                                                                                                                  type AudioPidSelection struct {
                                                                                                                  
                                                                                                                  	// Selects a specific PID from within a source.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Pid int32
                                                                                                                  }

                                                                                                                    Audio Pid Selection

                                                                                                                    type AudioSelector

                                                                                                                    type AudioSelector struct {
                                                                                                                    
                                                                                                                    	// The name of this AudioSelector. AudioDescriptions will use this name to uniquely
                                                                                                                    	// identify this Selector. Selector names should be unique per input.
                                                                                                                    	//
                                                                                                                    	// This member is required.
                                                                                                                    	Name *string
                                                                                                                    
                                                                                                                    	// The audio selector settings.
                                                                                                                    	SelectorSettings *AudioSelectorSettings
                                                                                                                    }

                                                                                                                      Audio Selector

                                                                                                                      type AudioSelectorSettings

                                                                                                                      type AudioSelectorSettings struct {
                                                                                                                      
                                                                                                                      	// Audio Language Selection
                                                                                                                      	AudioLanguageSelection *AudioLanguageSelection
                                                                                                                      
                                                                                                                      	// Audio Pid Selection
                                                                                                                      	AudioPidSelection *AudioPidSelection
                                                                                                                      
                                                                                                                      	// Audio Track Selection
                                                                                                                      	AudioTrackSelection *AudioTrackSelection
                                                                                                                      }

                                                                                                                        Audio Selector Settings

                                                                                                                        type AudioSilenceFailoverSettings

                                                                                                                        type AudioSilenceFailoverSettings struct {
                                                                                                                        
                                                                                                                        	// The name of the audio selector in the input that MediaLive should monitor to
                                                                                                                        	// detect silence. Select your most important rendition. If you didn't create an
                                                                                                                        	// audio selector in this input, leave blank.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	AudioSelectorName *string
                                                                                                                        
                                                                                                                        	// The amount of time (in milliseconds) that the active input must be silent before
                                                                                                                        	// automatic input failover occurs. Silence is defined as audio loss or audio
                                                                                                                        	// quieter than -50 dBFS.
                                                                                                                        	AudioSilenceThresholdMsec int32
                                                                                                                        }

                                                                                                                          Placeholder documentation for AudioSilenceFailoverSettings

                                                                                                                          type AudioTrack

                                                                                                                          type AudioTrack struct {
                                                                                                                          
                                                                                                                          	// 1-based integer value that maps to a specific audio track
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Track int32
                                                                                                                          }

                                                                                                                            Audio Track

                                                                                                                            type AudioTrackSelection

                                                                                                                            type AudioTrackSelection struct {
                                                                                                                            
                                                                                                                            	// Selects one or more unique audio tracks from within a source.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Tracks []AudioTrack
                                                                                                                            }

                                                                                                                              Audio Track Selection

                                                                                                                              type AudioType

                                                                                                                              type AudioType string
                                                                                                                              const (
                                                                                                                              	AudioTypeCleanEffects             AudioType = "CLEAN_EFFECTS"
                                                                                                                              	AudioTypeHearingImpaired          AudioType = "HEARING_IMPAIRED"
                                                                                                                              	AudioTypeUndefined                AudioType = "UNDEFINED"
                                                                                                                              	AudioTypeVisualImpairedCommentary AudioType = "VISUAL_IMPAIRED_COMMENTARY"
                                                                                                                              )

                                                                                                                                Enum values for AudioType

                                                                                                                                func (AudioType) Values

                                                                                                                                func (AudioType) Values() []AudioType

                                                                                                                                  Values returns all known values for AudioType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type AuthenticationScheme

                                                                                                                                  type AuthenticationScheme string
                                                                                                                                  const (
                                                                                                                                  	AuthenticationSchemeAkamai AuthenticationScheme = "AKAMAI"
                                                                                                                                  	AuthenticationSchemeCommon AuthenticationScheme = "COMMON"
                                                                                                                                  )

                                                                                                                                    Enum values for AuthenticationScheme

                                                                                                                                    func (AuthenticationScheme) Values

                                                                                                                                      Values returns all known values for AuthenticationScheme. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                      type AutomaticInputFailoverSettings

                                                                                                                                      type AutomaticInputFailoverSettings struct {
                                                                                                                                      
                                                                                                                                      	// The input ID of the secondary input in the automatic input failover pair.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	SecondaryInputId *string
                                                                                                                                      
                                                                                                                                      	// This clear time defines the requirement a recovered input must meet to be
                                                                                                                                      	// considered healthy. The input must have no failover conditions for this length
                                                                                                                                      	// of time. Enter a time in milliseconds. This value is particularly important if
                                                                                                                                      	// the input_preference for the failover pair is set to PRIMARY_INPUT_PREFERRED,
                                                                                                                                      	// because after this time, MediaLive will switch back to the primary input.
                                                                                                                                      	ErrorClearTimeMsec int32
                                                                                                                                      
                                                                                                                                      	// A list of failover conditions. If any of these conditions occur, MediaLive will
                                                                                                                                      	// perform a failover to the other input.
                                                                                                                                      	FailoverConditions []FailoverCondition
                                                                                                                                      
                                                                                                                                      	// Input preference when deciding which input to make active when a previously
                                                                                                                                      	// failed input has recovered.
                                                                                                                                      	InputPreference InputPreference
                                                                                                                                      }

                                                                                                                                        The settings for Automatic Input Failover.

                                                                                                                                        type AvailBlanking

                                                                                                                                        type AvailBlanking struct {
                                                                                                                                        
                                                                                                                                        	// Blanking image to be used. Leave empty for solid black. Only bmp and png images
                                                                                                                                        	// are supported.
                                                                                                                                        	AvailBlankingImage *InputLocation
                                                                                                                                        
                                                                                                                                        	// When set to enabled, causes video, audio and captions to be blanked when
                                                                                                                                        	// insertion metadata is added.
                                                                                                                                        	State AvailBlankingState
                                                                                                                                        }

                                                                                                                                          Avail Blanking

                                                                                                                                          type AvailBlankingState

                                                                                                                                          type AvailBlankingState string
                                                                                                                                          const (
                                                                                                                                          	AvailBlankingStateDisabled AvailBlankingState = "DISABLED"
                                                                                                                                          	AvailBlankingStateEnabled  AvailBlankingState = "ENABLED"
                                                                                                                                          )

                                                                                                                                            Enum values for AvailBlankingState

                                                                                                                                            func (AvailBlankingState) Values

                                                                                                                                              Values returns all known values for AvailBlankingState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                              type AvailConfiguration

                                                                                                                                              type AvailConfiguration struct {
                                                                                                                                              
                                                                                                                                              	// Ad avail settings.
                                                                                                                                              	AvailSettings *AvailSettings
                                                                                                                                              }

                                                                                                                                                Avail Configuration

                                                                                                                                                type AvailSettings

                                                                                                                                                type AvailSettings struct {
                                                                                                                                                
                                                                                                                                                	// Scte35 Splice Insert
                                                                                                                                                	Scte35SpliceInsert *Scte35SpliceInsert
                                                                                                                                                
                                                                                                                                                	// Scte35 Time Signal Apos
                                                                                                                                                	Scte35TimeSignalApos *Scte35TimeSignalApos
                                                                                                                                                }

                                                                                                                                                  Avail Settings

                                                                                                                                                  type BadGatewayException

                                                                                                                                                  type BadGatewayException struct {
                                                                                                                                                  	Message *string
                                                                                                                                                  }

                                                                                                                                                    Placeholder documentation for BadGatewayException

                                                                                                                                                    func (*BadGatewayException) Error

                                                                                                                                                    func (e *BadGatewayException) Error() string

                                                                                                                                                    func (*BadGatewayException) ErrorCode

                                                                                                                                                    func (e *BadGatewayException) ErrorCode() string

                                                                                                                                                    func (*BadGatewayException) ErrorFault

                                                                                                                                                    func (e *BadGatewayException) ErrorFault() smithy.ErrorFault

                                                                                                                                                    func (*BadGatewayException) ErrorMessage

                                                                                                                                                    func (e *BadGatewayException) ErrorMessage() string

                                                                                                                                                    type BadRequestException

                                                                                                                                                    type BadRequestException struct {
                                                                                                                                                    	Message *string
                                                                                                                                                    }

                                                                                                                                                      Placeholder documentation for BadRequestException

                                                                                                                                                      func (*BadRequestException) Error

                                                                                                                                                      func (e *BadRequestException) Error() string

                                                                                                                                                      func (*BadRequestException) ErrorCode

                                                                                                                                                      func (e *BadRequestException) ErrorCode() string

                                                                                                                                                      func (*BadRequestException) ErrorFault

                                                                                                                                                      func (e *BadRequestException) ErrorFault() smithy.ErrorFault

                                                                                                                                                      func (*BadRequestException) ErrorMessage

                                                                                                                                                      func (e *BadRequestException) ErrorMessage() string

                                                                                                                                                      type BatchFailedResultModel

                                                                                                                                                      type BatchFailedResultModel struct {
                                                                                                                                                      
                                                                                                                                                      	// ARN of the resource
                                                                                                                                                      	Arn *string
                                                                                                                                                      
                                                                                                                                                      	// Error code for the failed operation
                                                                                                                                                      	Code *string
                                                                                                                                                      
                                                                                                                                                      	// ID of the resource
                                                                                                                                                      	Id *string
                                                                                                                                                      
                                                                                                                                                      	// Error message for the failed operation
                                                                                                                                                      	Message *string
                                                                                                                                                      }

                                                                                                                                                        Details from a failed operation

                                                                                                                                                        type BatchScheduleActionCreateRequest

                                                                                                                                                        type BatchScheduleActionCreateRequest struct {
                                                                                                                                                        
                                                                                                                                                        	// A list of schedule actions to create.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	ScheduleActions []ScheduleAction
                                                                                                                                                        }

                                                                                                                                                          A list of schedule actions to create (in a request) or that have been created (in a response).

                                                                                                                                                          type BatchScheduleActionCreateResult

                                                                                                                                                          type BatchScheduleActionCreateResult struct {
                                                                                                                                                          
                                                                                                                                                          	// List of actions that have been created in the schedule.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	ScheduleActions []ScheduleAction
                                                                                                                                                          }

                                                                                                                                                            List of actions that have been created in the schedule.

                                                                                                                                                            type BatchScheduleActionDeleteRequest

                                                                                                                                                            type BatchScheduleActionDeleteRequest struct {
                                                                                                                                                            
                                                                                                                                                            	// A list of schedule actions to delete.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	ActionNames []string
                                                                                                                                                            }

                                                                                                                                                              A list of schedule actions to delete.

                                                                                                                                                              type BatchScheduleActionDeleteResult

                                                                                                                                                              type BatchScheduleActionDeleteResult struct {
                                                                                                                                                              
                                                                                                                                                              	// List of actions that have been deleted from the schedule.
                                                                                                                                                              	//
                                                                                                                                                              	// This member is required.
                                                                                                                                                              	ScheduleActions []ScheduleAction
                                                                                                                                                              }

                                                                                                                                                                List of actions that have been deleted from the schedule.

                                                                                                                                                                type BatchSuccessfulResultModel

                                                                                                                                                                type BatchSuccessfulResultModel struct {
                                                                                                                                                                
                                                                                                                                                                	// ARN of the resource
                                                                                                                                                                	Arn *string
                                                                                                                                                                
                                                                                                                                                                	// ID of the resource
                                                                                                                                                                	Id *string
                                                                                                                                                                
                                                                                                                                                                	// Current state of the resource
                                                                                                                                                                	State *string
                                                                                                                                                                }

                                                                                                                                                                  Details from a successful operation

                                                                                                                                                                  type BlackoutSlate

                                                                                                                                                                  type BlackoutSlate struct {
                                                                                                                                                                  
                                                                                                                                                                  	// Blackout slate image to be used. Leave empty for solid black. Only bmp and png
                                                                                                                                                                  	// images are supported.
                                                                                                                                                                  	BlackoutSlateImage *InputLocation
                                                                                                                                                                  
                                                                                                                                                                  	// Setting to enabled causes the encoder to blackout the video, audio, and
                                                                                                                                                                  	// captions, and raise the "Network Blackout Image" slate when an SCTE104/35
                                                                                                                                                                  	// Network End Segmentation Descriptor is encountered. The blackout will be lifted
                                                                                                                                                                  	// when the Network Start Segmentation Descriptor is encountered. The Network End
                                                                                                                                                                  	// and Network Start descriptors must contain a network ID that matches the value
                                                                                                                                                                  	// entered in "Network ID".
                                                                                                                                                                  	NetworkEndBlackout BlackoutSlateNetworkEndBlackout
                                                                                                                                                                  
                                                                                                                                                                  	// Path to local file to use as Network End Blackout image. Image will be scaled to
                                                                                                                                                                  	// fill the entire output raster.
                                                                                                                                                                  	NetworkEndBlackoutImage *InputLocation
                                                                                                                                                                  
                                                                                                                                                                  	// Provides Network ID that matches EIDR ID format (e.g.,
                                                                                                                                                                  	// "10.XXXX/XXXX-XXXX-XXXX-XXXX-XXXX-C").
                                                                                                                                                                  	NetworkId *string
                                                                                                                                                                  
                                                                                                                                                                  	// When set to enabled, causes video, audio and captions to be blanked when
                                                                                                                                                                  	// indicated by program metadata.
                                                                                                                                                                  	State BlackoutSlateState
                                                                                                                                                                  }

                                                                                                                                                                    Blackout Slate

                                                                                                                                                                    type BlackoutSlateNetworkEndBlackout

                                                                                                                                                                    type BlackoutSlateNetworkEndBlackout string
                                                                                                                                                                    const (
                                                                                                                                                                    	BlackoutSlateNetworkEndBlackoutDisabled BlackoutSlateNetworkEndBlackout = "DISABLED"
                                                                                                                                                                    	BlackoutSlateNetworkEndBlackoutEnabled  BlackoutSlateNetworkEndBlackout = "ENABLED"
                                                                                                                                                                    )

                                                                                                                                                                      Enum values for BlackoutSlateNetworkEndBlackout

                                                                                                                                                                      func (BlackoutSlateNetworkEndBlackout) Values

                                                                                                                                                                        Values returns all known values for BlackoutSlateNetworkEndBlackout. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                        type BlackoutSlateState

                                                                                                                                                                        type BlackoutSlateState string
                                                                                                                                                                        const (
                                                                                                                                                                        	BlackoutSlateStateDisabled BlackoutSlateState = "DISABLED"
                                                                                                                                                                        	BlackoutSlateStateEnabled  BlackoutSlateState = "ENABLED"
                                                                                                                                                                        )

                                                                                                                                                                          Enum values for BlackoutSlateState

                                                                                                                                                                          func (BlackoutSlateState) Values

                                                                                                                                                                            Values returns all known values for BlackoutSlateState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                            type BurnInAlignment

                                                                                                                                                                            type BurnInAlignment string
                                                                                                                                                                            const (
                                                                                                                                                                            	BurnInAlignmentCentered BurnInAlignment = "CENTERED"
                                                                                                                                                                            	BurnInAlignmentLeft     BurnInAlignment = "LEFT"
                                                                                                                                                                            	BurnInAlignmentSmart    BurnInAlignment = "SMART"
                                                                                                                                                                            )

                                                                                                                                                                              Enum values for BurnInAlignment

                                                                                                                                                                              func (BurnInAlignment) Values

                                                                                                                                                                              func (BurnInAlignment) Values() []BurnInAlignment

                                                                                                                                                                                Values returns all known values for BurnInAlignment. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                type BurnInBackgroundColor

                                                                                                                                                                                type BurnInBackgroundColor string
                                                                                                                                                                                const (
                                                                                                                                                                                	BurnInBackgroundColorBlack BurnInBackgroundColor = "BLACK"
                                                                                                                                                                                	BurnInBackgroundColorNone  BurnInBackgroundColor = "NONE"
                                                                                                                                                                                	BurnInBackgroundColorWhite BurnInBackgroundColor = "WHITE"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for BurnInBackgroundColor

                                                                                                                                                                                  func (BurnInBackgroundColor) Values

                                                                                                                                                                                    Values returns all known values for BurnInBackgroundColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                    type BurnInDestinationSettings

                                                                                                                                                                                    type BurnInDestinationSettings struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// If no explicit xPosition or yPosition is provided, setting alignment to centered
                                                                                                                                                                                    	// will place the captions at the bottom center of the output. Similarly, setting a
                                                                                                                                                                                    	// left alignment will align captions to the bottom left of the output. If x and y
                                                                                                                                                                                    	// positions are given in conjunction with the alignment parameter, the font will
                                                                                                                                                                                    	// be justified (either left or centered) relative to those coordinates. Selecting
                                                                                                                                                                                    	// "smart" justification will left-justify live subtitles and center-justify
                                                                                                                                                                                    	// pre-recorded subtitles. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	Alignment BurnInAlignment
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the color of the rectangle behind the captions. All burn-in and
                                                                                                                                                                                    	// DVB-Sub font settings must match.
                                                                                                                                                                                    	BackgroundColor BurnInBackgroundColor
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the opacity of the background rectangle. 255 is opaque; 0 is
                                                                                                                                                                                    	// transparent. Leaving this parameter out is equivalent to setting it to 0
                                                                                                                                                                                    	// (transparent). All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	BackgroundOpacity int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// External font file used for caption burn-in. File extension must be 'ttf' or
                                                                                                                                                                                    	// 'tte'. Although the user can select output fonts for many different types of
                                                                                                                                                                                    	// input captions, embedded, STL and teletext sources use a strict grid system.
                                                                                                                                                                                    	// Using external fonts with these caption sources could cause unexpected display
                                                                                                                                                                                    	// of proportional fonts. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	Font *InputLocation
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the color of the burned-in captions. This option is not valid for
                                                                                                                                                                                    	// source captions that are STL, 608/embedded or teletext. These source settings
                                                                                                                                                                                    	// are already pre-defined by the caption stream. All burn-in and DVB-Sub font
                                                                                                                                                                                    	// settings must match.
                                                                                                                                                                                    	FontColor BurnInFontColor
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the opacity of the burned-in captions. 255 is opaque; 0 is
                                                                                                                                                                                    	// transparent. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	FontOpacity int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Font resolution in DPI (dots per inch); default is 96 dpi. All burn-in and
                                                                                                                                                                                    	// DVB-Sub font settings must match.
                                                                                                                                                                                    	FontResolution int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// When set to 'auto' fontSize will scale depending on the size of the output.
                                                                                                                                                                                    	// Giving a positive integer will specify the exact font size in points. All
                                                                                                                                                                                    	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	FontSize *string
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies font outline color. This option is not valid for source captions that
                                                                                                                                                                                    	// are either 608/embedded or teletext. These source settings are already
                                                                                                                                                                                    	// pre-defined by the caption stream. All burn-in and DVB-Sub font settings must
                                                                                                                                                                                    	// match.
                                                                                                                                                                                    	OutlineColor BurnInOutlineColor
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies font outline size in pixels. This option is not valid for source
                                                                                                                                                                                    	// captions that are either 608/embedded or teletext. These source settings are
                                                                                                                                                                                    	// already pre-defined by the caption stream. All burn-in and DVB-Sub font settings
                                                                                                                                                                                    	// must match.
                                                                                                                                                                                    	OutlineSize int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the color of the shadow cast by the captions. All burn-in and DVB-Sub
                                                                                                                                                                                    	// font settings must match.
                                                                                                                                                                                    	ShadowColor BurnInShadowColor
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the opacity of the shadow. 255 is opaque; 0 is transparent. Leaving
                                                                                                                                                                                    	// this parameter out is equivalent to setting it to 0 (transparent). All burn-in
                                                                                                                                                                                    	// and DVB-Sub font settings must match.
                                                                                                                                                                                    	ShadowOpacity int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the horizontal offset of the shadow relative to the captions in
                                                                                                                                                                                    	// pixels. A value of -2 would result in a shadow offset 2 pixels to the left. All
                                                                                                                                                                                    	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	ShadowXOffset int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the vertical offset of the shadow relative to the captions in pixels.
                                                                                                                                                                                    	// A value of -2 would result in a shadow offset 2 pixels above the text. All
                                                                                                                                                                                    	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	ShadowYOffset int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Controls whether a fixed grid size will be used to generate the output subtitles
                                                                                                                                                                                    	// bitmap. Only applicable for Teletext inputs and DVB-Sub/Burn-in outputs.
                                                                                                                                                                                    	TeletextGridControl BurnInTeletextGridControl
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the horizontal position of the caption relative to the left side of
                                                                                                                                                                                    	// the output in pixels. A value of 10 would result in the captions starting 10
                                                                                                                                                                                    	// pixels from the left of the output. If no explicit xPosition is provided, the
                                                                                                                                                                                    	// horizontal caption position will be determined by the alignment parameter. All
                                                                                                                                                                                    	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                    	XPosition int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Specifies the vertical position of the caption relative to the top of the output
                                                                                                                                                                                    	// in pixels. A value of 10 would result in the captions starting 10 pixels from
                                                                                                                                                                                    	// the top of the output. If no explicit yPosition is provided, the caption will be
                                                                                                                                                                                    	// positioned towards the bottom of the output. All burn-in and DVB-Sub font
                                                                                                                                                                                    	// settings must match.
                                                                                                                                                                                    	YPosition int32
                                                                                                                                                                                    }

                                                                                                                                                                                      Burn In Destination Settings

                                                                                                                                                                                      type BurnInFontColor

                                                                                                                                                                                      type BurnInFontColor string
                                                                                                                                                                                      const (
                                                                                                                                                                                      	BurnInFontColorBlack  BurnInFontColor = "BLACK"
                                                                                                                                                                                      	BurnInFontColorBlue   BurnInFontColor = "BLUE"
                                                                                                                                                                                      	BurnInFontColorGreen  BurnInFontColor = "GREEN"
                                                                                                                                                                                      	BurnInFontColorRed    BurnInFontColor = "RED"
                                                                                                                                                                                      	BurnInFontColorWhite  BurnInFontColor = "WHITE"
                                                                                                                                                                                      	BurnInFontColorYellow BurnInFontColor = "YELLOW"
                                                                                                                                                                                      )

                                                                                                                                                                                        Enum values for BurnInFontColor

                                                                                                                                                                                        func (BurnInFontColor) Values

                                                                                                                                                                                        func (BurnInFontColor) Values() []BurnInFontColor

                                                                                                                                                                                          Values returns all known values for BurnInFontColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                          type BurnInOutlineColor

                                                                                                                                                                                          type BurnInOutlineColor string
                                                                                                                                                                                          const (
                                                                                                                                                                                          	BurnInOutlineColorBlack  BurnInOutlineColor = "BLACK"
                                                                                                                                                                                          	BurnInOutlineColorBlue   BurnInOutlineColor = "BLUE"
                                                                                                                                                                                          	BurnInOutlineColorGreen  BurnInOutlineColor = "GREEN"
                                                                                                                                                                                          	BurnInOutlineColorRed    BurnInOutlineColor = "RED"
                                                                                                                                                                                          	BurnInOutlineColorWhite  BurnInOutlineColor = "WHITE"
                                                                                                                                                                                          	BurnInOutlineColorYellow BurnInOutlineColor = "YELLOW"
                                                                                                                                                                                          )

                                                                                                                                                                                            Enum values for BurnInOutlineColor

                                                                                                                                                                                            func (BurnInOutlineColor) Values

                                                                                                                                                                                              Values returns all known values for BurnInOutlineColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                              type BurnInShadowColor

                                                                                                                                                                                              type BurnInShadowColor string
                                                                                                                                                                                              const (
                                                                                                                                                                                              	BurnInShadowColorBlack BurnInShadowColor = "BLACK"
                                                                                                                                                                                              	BurnInShadowColorNone  BurnInShadowColor = "NONE"
                                                                                                                                                                                              	BurnInShadowColorWhite BurnInShadowColor = "WHITE"
                                                                                                                                                                                              )

                                                                                                                                                                                                Enum values for BurnInShadowColor

                                                                                                                                                                                                func (BurnInShadowColor) Values

                                                                                                                                                                                                  Values returns all known values for BurnInShadowColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                  type BurnInTeletextGridControl

                                                                                                                                                                                                  type BurnInTeletextGridControl string
                                                                                                                                                                                                  const (
                                                                                                                                                                                                  	BurnInTeletextGridControlFixed  BurnInTeletextGridControl = "FIXED"
                                                                                                                                                                                                  	BurnInTeletextGridControlScaled BurnInTeletextGridControl = "SCALED"
                                                                                                                                                                                                  )

                                                                                                                                                                                                    Enum values for BurnInTeletextGridControl

                                                                                                                                                                                                    func (BurnInTeletextGridControl) Values

                                                                                                                                                                                                      Values returns all known values for BurnInTeletextGridControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                      type CaptionDescription

                                                                                                                                                                                                      type CaptionDescription struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Specifies which input caption selector to use as a caption source when
                                                                                                                                                                                                      	// generating output captions. This field should match a captionSelector name.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	CaptionSelectorName *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Name of the caption description. Used to associate a caption description with an
                                                                                                                                                                                                      	// output. Names must be unique within an event.
                                                                                                                                                                                                      	//
                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Additional settings for captions destination that depend on the destination
                                                                                                                                                                                                      	// type.
                                                                                                                                                                                                      	DestinationSettings *CaptionDestinationSettings
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// ISO 639-2 three-digit code: http://www.loc.gov/standards/iso639-2/
                                                                                                                                                                                                      	LanguageCode *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Human readable information to indicate captions available for players (eg.
                                                                                                                                                                                                      	// English, or Spanish).
                                                                                                                                                                                                      	LanguageDescription *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        Caption Description

                                                                                                                                                                                                        type CaptionDestinationSettings

                                                                                                                                                                                                        type CaptionDestinationSettings struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Arib Destination Settings
                                                                                                                                                                                                        	AribDestinationSettings *AribDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Burn In Destination Settings
                                                                                                                                                                                                        	BurnInDestinationSettings *BurnInDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Dvb Sub Destination Settings
                                                                                                                                                                                                        	DvbSubDestinationSettings *DvbSubDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Ebu Tt DDestination Settings
                                                                                                                                                                                                        	EbuTtDDestinationSettings *EbuTtDDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Embedded Destination Settings
                                                                                                                                                                                                        	EmbeddedDestinationSettings *EmbeddedDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Embedded Plus Scte20 Destination Settings
                                                                                                                                                                                                        	EmbeddedPlusScte20DestinationSettings *EmbeddedPlusScte20DestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Rtmp Caption Info Destination Settings
                                                                                                                                                                                                        	RtmpCaptionInfoDestinationSettings *RtmpCaptionInfoDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Scte20 Plus Embedded Destination Settings
                                                                                                                                                                                                        	Scte20PlusEmbeddedDestinationSettings *Scte20PlusEmbeddedDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Scte27 Destination Settings
                                                                                                                                                                                                        	Scte27DestinationSettings *Scte27DestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Smpte Tt Destination Settings
                                                                                                                                                                                                        	SmpteTtDestinationSettings *SmpteTtDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Teletext Destination Settings
                                                                                                                                                                                                        	TeletextDestinationSettings *TeletextDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Ttml Destination Settings
                                                                                                                                                                                                        	TtmlDestinationSettings *TtmlDestinationSettings
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Webvtt Destination Settings
                                                                                                                                                                                                        	WebvttDestinationSettings *WebvttDestinationSettings
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Caption Destination Settings

                                                                                                                                                                                                          type CaptionLanguageMapping

                                                                                                                                                                                                          type CaptionLanguageMapping struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The closed caption channel being described by this CaptionLanguageMapping. Each
                                                                                                                                                                                                          	// channel mapping must have a unique channel number (maximum of 4)
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	CaptionChannel int32
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Three character ISO 639-2 language code (see
                                                                                                                                                                                                          	// http://www.loc.gov/standards/iso639-2)
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	LanguageCode *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Textual description of language
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	LanguageDescription *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Maps a caption channel to an ISO 693-2 language code (http://www.loc.gov/standards/iso639-2), with an optional description.

                                                                                                                                                                                                            type CaptionSelector

                                                                                                                                                                                                            type CaptionSelector struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Name identifier for a caption selector. This name is used to associate this
                                                                                                                                                                                                            	// caption selector with one or more caption descriptions. Names must be unique
                                                                                                                                                                                                            	// within an event.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// When specified this field indicates the three letter language code of the
                                                                                                                                                                                                            	// caption track to extract from the source.
                                                                                                                                                                                                            	LanguageCode *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Caption selector settings.
                                                                                                                                                                                                            	SelectorSettings *CaptionSelectorSettings
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Output groups for this Live Event. Output groups contain information about where streams should be distributed.

                                                                                                                                                                                                              type CaptionSelectorSettings

                                                                                                                                                                                                              type CaptionSelectorSettings struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Ancillary Source Settings
                                                                                                                                                                                                              	AncillarySourceSettings *AncillarySourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Arib Source Settings
                                                                                                                                                                                                              	AribSourceSettings *AribSourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Dvb Sub Source Settings
                                                                                                                                                                                                              	DvbSubSourceSettings *DvbSubSourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Embedded Source Settings
                                                                                                                                                                                                              	EmbeddedSourceSettings *EmbeddedSourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Scte20 Source Settings
                                                                                                                                                                                                              	Scte20SourceSettings *Scte20SourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Scte27 Source Settings
                                                                                                                                                                                                              	Scte27SourceSettings *Scte27SourceSettings
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Teletext Source Settings
                                                                                                                                                                                                              	TeletextSourceSettings *TeletextSourceSettings
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Caption Selector Settings

                                                                                                                                                                                                                type CdiInputResolution

                                                                                                                                                                                                                type CdiInputResolution string
                                                                                                                                                                                                                const (
                                                                                                                                                                                                                	CdiInputResolutionSd  CdiInputResolution = "SD"
                                                                                                                                                                                                                	CdiInputResolutionHd  CdiInputResolution = "HD"
                                                                                                                                                                                                                	CdiInputResolutionFhd CdiInputResolution = "FHD"
                                                                                                                                                                                                                	CdiInputResolutionUhd CdiInputResolution = "UHD"
                                                                                                                                                                                                                )

                                                                                                                                                                                                                  Enum values for CdiInputResolution

                                                                                                                                                                                                                  func (CdiInputResolution) Values

                                                                                                                                                                                                                    Values returns all known values for CdiInputResolution. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                    type CdiInputSpecification

                                                                                                                                                                                                                    type CdiInputSpecification struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Maximum CDI input resolution
                                                                                                                                                                                                                    	Resolution CdiInputResolution
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Placeholder documentation for CdiInputSpecification

                                                                                                                                                                                                                      type Channel

                                                                                                                                                                                                                      type Channel struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The unique arn of the channel.
                                                                                                                                                                                                                      	Arn *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Specification of CDI inputs for this channel
                                                                                                                                                                                                                      	CdiInputSpecification *CdiInputSpecification
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The class for this channel. STANDARD for a channel with two pipelines or
                                                                                                                                                                                                                      	// SINGLE_PIPELINE for a channel with one pipeline.
                                                                                                                                                                                                                      	ChannelClass ChannelClass
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// A list of destinations of the channel. For UDP outputs, there is one destination
                                                                                                                                                                                                                      	// per output. For other types (HLS, for example), there is one destination per
                                                                                                                                                                                                                      	// packager.
                                                                                                                                                                                                                      	Destinations []OutputDestination
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The endpoints where outgoing connections initiate from
                                                                                                                                                                                                                      	EgressEndpoints []ChannelEgressEndpoint
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Encoder Settings
                                                                                                                                                                                                                      	EncoderSettings *EncoderSettings
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The unique id of the channel.
                                                                                                                                                                                                                      	Id *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// List of input attachments for channel.
                                                                                                                                                                                                                      	InputAttachments []InputAttachment
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Specification of network and file inputs for this channel
                                                                                                                                                                                                                      	InputSpecification *InputSpecification
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The log level being written to CloudWatch Logs.
                                                                                                                                                                                                                      	LogLevel LogLevel
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name of the channel. (user-mutable)
                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Runtime details for the pipelines of a running channel.
                                                                                                                                                                                                                      	PipelineDetails []PipelineDetail
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The number of currently healthy pipelines.
                                                                                                                                                                                                                      	PipelinesRunningCount int32
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the role assumed when running the Channel.
                                                                                                                                                                                                                      	RoleArn *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Placeholder documentation for ChannelState
                                                                                                                                                                                                                      	State ChannelState
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// A collection of key-value pairs.
                                                                                                                                                                                                                      	Tags map[string]string
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Placeholder documentation for Channel

                                                                                                                                                                                                                        type ChannelClass

                                                                                                                                                                                                                        type ChannelClass string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	ChannelClassStandard       ChannelClass = "STANDARD"
                                                                                                                                                                                                                        	ChannelClassSinglePipeline ChannelClass = "SINGLE_PIPELINE"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for ChannelClass

                                                                                                                                                                                                                          func (ChannelClass) Values

                                                                                                                                                                                                                          func (ChannelClass) Values() []ChannelClass

                                                                                                                                                                                                                            Values returns all known values for ChannelClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type ChannelEgressEndpoint

                                                                                                                                                                                                                            type ChannelEgressEndpoint struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Public IP of where a channel's output comes from
                                                                                                                                                                                                                            	SourceIp *string
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Placeholder documentation for ChannelEgressEndpoint

                                                                                                                                                                                                                              type ChannelState

                                                                                                                                                                                                                              type ChannelState string
                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                              	ChannelStateCreating     ChannelState = "CREATING"
                                                                                                                                                                                                                              	ChannelStateCreateFailed ChannelState = "CREATE_FAILED"
                                                                                                                                                                                                                              	ChannelStateIdle         ChannelState = "IDLE"
                                                                                                                                                                                                                              	ChannelStateStarting     ChannelState = "STARTING"
                                                                                                                                                                                                                              	ChannelStateRunning      ChannelState = "RUNNING"
                                                                                                                                                                                                                              	ChannelStateRecovering   ChannelState = "RECOVERING"
                                                                                                                                                                                                                              	ChannelStateStopping     ChannelState = "STOPPING"
                                                                                                                                                                                                                              	ChannelStateDeleting     ChannelState = "DELETING"
                                                                                                                                                                                                                              	ChannelStateDeleted      ChannelState = "DELETED"
                                                                                                                                                                                                                              	ChannelStateUpdating     ChannelState = "UPDATING"
                                                                                                                                                                                                                              	ChannelStateUpdateFailed ChannelState = "UPDATE_FAILED"
                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                Enum values for ChannelState

                                                                                                                                                                                                                                func (ChannelState) Values

                                                                                                                                                                                                                                func (ChannelState) Values() []ChannelState

                                                                                                                                                                                                                                  Values returns all known values for ChannelState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                  type ChannelSummary

                                                                                                                                                                                                                                  type ChannelSummary struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The unique arn of the channel.
                                                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Specification of CDI inputs for this channel
                                                                                                                                                                                                                                  	CdiInputSpecification *CdiInputSpecification
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The class for this channel. STANDARD for a channel with two pipelines or
                                                                                                                                                                                                                                  	// SINGLE_PIPELINE for a channel with one pipeline.
                                                                                                                                                                                                                                  	ChannelClass ChannelClass
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// A list of destinations of the channel. For UDP outputs, there is one destination
                                                                                                                                                                                                                                  	// per output. For other types (HLS, for example), there is one destination per
                                                                                                                                                                                                                                  	// packager.
                                                                                                                                                                                                                                  	Destinations []OutputDestination
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The endpoints where outgoing connections initiate from
                                                                                                                                                                                                                                  	EgressEndpoints []ChannelEgressEndpoint
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The unique id of the channel.
                                                                                                                                                                                                                                  	Id *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// List of input attachments for channel.
                                                                                                                                                                                                                                  	InputAttachments []InputAttachment
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Specification of network and file inputs for this channel
                                                                                                                                                                                                                                  	InputSpecification *InputSpecification
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The log level being written to CloudWatch Logs.
                                                                                                                                                                                                                                  	LogLevel LogLevel
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The name of the channel. (user-mutable)
                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The number of currently healthy pipelines.
                                                                                                                                                                                                                                  	PipelinesRunningCount int32
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the role assumed when running the Channel.
                                                                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Placeholder documentation for ChannelState
                                                                                                                                                                                                                                  	State ChannelState
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// A collection of key-value pairs.
                                                                                                                                                                                                                                  	Tags map[string]string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Placeholder documentation for ChannelSummary

                                                                                                                                                                                                                                    type ColorSpacePassthroughSettings

                                                                                                                                                                                                                                    type ColorSpacePassthroughSettings struct {
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Passthrough applies no color space conversion to the output

                                                                                                                                                                                                                                      type ConflictException

                                                                                                                                                                                                                                      type ConflictException struct {
                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Placeholder documentation for ConflictException

                                                                                                                                                                                                                                        func (*ConflictException) Error

                                                                                                                                                                                                                                        func (e *ConflictException) Error() string

                                                                                                                                                                                                                                        func (*ConflictException) ErrorCode

                                                                                                                                                                                                                                        func (e *ConflictException) ErrorCode() string

                                                                                                                                                                                                                                        func (*ConflictException) ErrorFault

                                                                                                                                                                                                                                        func (e *ConflictException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                        func (*ConflictException) ErrorMessage

                                                                                                                                                                                                                                        func (e *ConflictException) ErrorMessage() string

                                                                                                                                                                                                                                        type ContentType

                                                                                                                                                                                                                                        type ContentType string
                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                        	ContentTypeImageJpeg ContentType = "image/jpeg"
                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                          Enum values for ContentType

                                                                                                                                                                                                                                          func (ContentType) Values

                                                                                                                                                                                                                                          func (ContentType) Values() []ContentType

                                                                                                                                                                                                                                            Values returns all known values for ContentType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                            type DeviceSettingsSyncState

                                                                                                                                                                                                                                            type DeviceSettingsSyncState string
                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                            	DeviceSettingsSyncStateSynced  DeviceSettingsSyncState = "SYNCED"
                                                                                                                                                                                                                                            	DeviceSettingsSyncStateSyncing DeviceSettingsSyncState = "SYNCING"
                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                              Enum values for DeviceSettingsSyncState

                                                                                                                                                                                                                                              func (DeviceSettingsSyncState) Values

                                                                                                                                                                                                                                                Values returns all known values for DeviceSettingsSyncState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                type DeviceUpdateStatus

                                                                                                                                                                                                                                                type DeviceUpdateStatus string
                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                	DeviceUpdateStatusUpToDate    DeviceUpdateStatus = "UP_TO_DATE"
                                                                                                                                                                                                                                                	DeviceUpdateStatusNotUpToDate DeviceUpdateStatus = "NOT_UP_TO_DATE"
                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                  Enum values for DeviceUpdateStatus

                                                                                                                                                                                                                                                  func (DeviceUpdateStatus) Values

                                                                                                                                                                                                                                                    Values returns all known values for DeviceUpdateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                    type DvbNitSettings

                                                                                                                                                                                                                                                    type DvbNitSettings struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The numeric value placed in the Network Information Table (NIT).
                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                    	NetworkId int32
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The network name text placed in the networkNameDescriptor inside the Network
                                                                                                                                                                                                                                                    	// Information Table. Maximum length is 256 characters.
                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                    	NetworkName *string
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The number of milliseconds between instances of this table in the output
                                                                                                                                                                                                                                                    	// transport stream.
                                                                                                                                                                                                                                                    	RepInterval int32
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      DVB Network Information Table (NIT)

                                                                                                                                                                                                                                                      type DvbSdtOutputSdt

                                                                                                                                                                                                                                                      type DvbSdtOutputSdt string
                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                      	DvbSdtOutputSdtSdtFollow          DvbSdtOutputSdt = "SDT_FOLLOW"
                                                                                                                                                                                                                                                      	DvbSdtOutputSdtSdtFollowIfPresent DvbSdtOutputSdt = "SDT_FOLLOW_IF_PRESENT"
                                                                                                                                                                                                                                                      	DvbSdtOutputSdtSdtManual          DvbSdtOutputSdt = "SDT_MANUAL"
                                                                                                                                                                                                                                                      	DvbSdtOutputSdtSdtNone            DvbSdtOutputSdt = "SDT_NONE"
                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                        Enum values for DvbSdtOutputSdt

                                                                                                                                                                                                                                                        func (DvbSdtOutputSdt) Values

                                                                                                                                                                                                                                                        func (DvbSdtOutputSdt) Values() []DvbSdtOutputSdt

                                                                                                                                                                                                                                                          Values returns all known values for DvbSdtOutputSdt. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                          type DvbSdtSettings

                                                                                                                                                                                                                                                          type DvbSdtSettings struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Selects method of inserting SDT information into output stream. The sdtFollow
                                                                                                                                                                                                                                                          	// setting copies SDT information from input stream to output stream. The
                                                                                                                                                                                                                                                          	// sdtFollowIfPresent setting copies SDT information from input stream to output
                                                                                                                                                                                                                                                          	// stream if SDT information is present in the input, otherwise it will fall back
                                                                                                                                                                                                                                                          	// on the user-defined values. The sdtManual setting means user will enter the SDT
                                                                                                                                                                                                                                                          	// information. The sdtNone setting means output stream will not contain SDT
                                                                                                                                                                                                                                                          	// information.
                                                                                                                                                                                                                                                          	OutputSdt DvbSdtOutputSdt
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The number of milliseconds between instances of this table in the output
                                                                                                                                                                                                                                                          	// transport stream.
                                                                                                                                                                                                                                                          	RepInterval int32
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The service name placed in the serviceDescriptor in the Service Description
                                                                                                                                                                                                                                                          	// Table. Maximum length is 256 characters.
                                                                                                                                                                                                                                                          	ServiceName *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The service provider name placed in the serviceDescriptor in the Service
                                                                                                                                                                                                                                                          	// Description Table. Maximum length is 256 characters.
                                                                                                                                                                                                                                                          	ServiceProviderName *string
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            DVB Service Description Table (SDT)

                                                                                                                                                                                                                                                            type DvbSubDestinationAlignment

                                                                                                                                                                                                                                                            type DvbSubDestinationAlignment string
                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                            	DvbSubDestinationAlignmentCentered DvbSubDestinationAlignment = "CENTERED"
                                                                                                                                                                                                                                                            	DvbSubDestinationAlignmentLeft     DvbSubDestinationAlignment = "LEFT"
                                                                                                                                                                                                                                                            	DvbSubDestinationAlignmentSmart    DvbSubDestinationAlignment = "SMART"
                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                              Enum values for DvbSubDestinationAlignment

                                                                                                                                                                                                                                                              func (DvbSubDestinationAlignment) Values

                                                                                                                                                                                                                                                                Values returns all known values for DvbSubDestinationAlignment. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                type DvbSubDestinationBackgroundColor

                                                                                                                                                                                                                                                                type DvbSubDestinationBackgroundColor string
                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                	DvbSubDestinationBackgroundColorBlack DvbSubDestinationBackgroundColor = "BLACK"
                                                                                                                                                                                                                                                                	DvbSubDestinationBackgroundColorNone  DvbSubDestinationBackgroundColor = "NONE"
                                                                                                                                                                                                                                                                	DvbSubDestinationBackgroundColorWhite DvbSubDestinationBackgroundColor = "WHITE"
                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                  Enum values for DvbSubDestinationBackgroundColor

                                                                                                                                                                                                                                                                  func (DvbSubDestinationBackgroundColor) Values

                                                                                                                                                                                                                                                                    Values returns all known values for DvbSubDestinationBackgroundColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                    type DvbSubDestinationFontColor

                                                                                                                                                                                                                                                                    type DvbSubDestinationFontColor string
                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorBlack  DvbSubDestinationFontColor = "BLACK"
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorBlue   DvbSubDestinationFontColor = "BLUE"
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorGreen  DvbSubDestinationFontColor = "GREEN"
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorRed    DvbSubDestinationFontColor = "RED"
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorWhite  DvbSubDestinationFontColor = "WHITE"
                                                                                                                                                                                                                                                                    	DvbSubDestinationFontColorYellow DvbSubDestinationFontColor = "YELLOW"
                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                      Enum values for DvbSubDestinationFontColor

                                                                                                                                                                                                                                                                      func (DvbSubDestinationFontColor) Values

                                                                                                                                                                                                                                                                        Values returns all known values for DvbSubDestinationFontColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                        type DvbSubDestinationOutlineColor

                                                                                                                                                                                                                                                                        type DvbSubDestinationOutlineColor string
                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorBlack  DvbSubDestinationOutlineColor = "BLACK"
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorBlue   DvbSubDestinationOutlineColor = "BLUE"
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorGreen  DvbSubDestinationOutlineColor = "GREEN"
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorRed    DvbSubDestinationOutlineColor = "RED"
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorWhite  DvbSubDestinationOutlineColor = "WHITE"
                                                                                                                                                                                                                                                                        	DvbSubDestinationOutlineColorYellow DvbSubDestinationOutlineColor = "YELLOW"
                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                          Enum values for DvbSubDestinationOutlineColor

                                                                                                                                                                                                                                                                          func (DvbSubDestinationOutlineColor) Values

                                                                                                                                                                                                                                                                            Values returns all known values for DvbSubDestinationOutlineColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                            type DvbSubDestinationSettings

                                                                                                                                                                                                                                                                            type DvbSubDestinationSettings struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// If no explicit xPosition or yPosition is provided, setting alignment to centered
                                                                                                                                                                                                                                                                            	// will place the captions at the bottom center of the output. Similarly, setting a
                                                                                                                                                                                                                                                                            	// left alignment will align captions to the bottom left of the output. If x and y
                                                                                                                                                                                                                                                                            	// positions are given in conjunction with the alignment parameter, the font will
                                                                                                                                                                                                                                                                            	// be justified (either left or centered) relative to those coordinates. Selecting
                                                                                                                                                                                                                                                                            	// "smart" justification will left-justify live subtitles and center-justify
                                                                                                                                                                                                                                                                            	// pre-recorded subtitles. This option is not valid for source captions that are
                                                                                                                                                                                                                                                                            	// STL or 608/embedded. These source settings are already pre-defined by the
                                                                                                                                                                                                                                                                            	// caption stream. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	Alignment DvbSubDestinationAlignment
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the color of the rectangle behind the captions. All burn-in and
                                                                                                                                                                                                                                                                            	// DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	BackgroundColor DvbSubDestinationBackgroundColor
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the opacity of the background rectangle. 255 is opaque; 0 is
                                                                                                                                                                                                                                                                            	// transparent. Leaving this parameter blank is equivalent to setting it to 0
                                                                                                                                                                                                                                                                            	// (transparent). All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	BackgroundOpacity int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// External font file used for caption burn-in. File extension must be 'ttf' or
                                                                                                                                                                                                                                                                            	// 'tte'. Although the user can select output fonts for many different types of
                                                                                                                                                                                                                                                                            	// input captions, embedded, STL and teletext sources use a strict grid system.
                                                                                                                                                                                                                                                                            	// Using external fonts with these caption sources could cause unexpected display
                                                                                                                                                                                                                                                                            	// of proportional fonts. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	Font *InputLocation
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the color of the burned-in captions. This option is not valid for
                                                                                                                                                                                                                                                                            	// source captions that are STL, 608/embedded or teletext. These source settings
                                                                                                                                                                                                                                                                            	// are already pre-defined by the caption stream. All burn-in and DVB-Sub font
                                                                                                                                                                                                                                                                            	// settings must match.
                                                                                                                                                                                                                                                                            	FontColor DvbSubDestinationFontColor
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the opacity of the burned-in captions. 255 is opaque; 0 is
                                                                                                                                                                                                                                                                            	// transparent. All burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	FontOpacity int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Font resolution in DPI (dots per inch); default is 96 dpi. All burn-in and
                                                                                                                                                                                                                                                                            	// DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	FontResolution int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// When set to auto fontSize will scale depending on the size of the output. Giving
                                                                                                                                                                                                                                                                            	// a positive integer will specify the exact font size in points. All burn-in and
                                                                                                                                                                                                                                                                            	// DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	FontSize *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies font outline color. This option is not valid for source captions that
                                                                                                                                                                                                                                                                            	// are either 608/embedded or teletext. These source settings are already
                                                                                                                                                                                                                                                                            	// pre-defined by the caption stream. All burn-in and DVB-Sub font settings must
                                                                                                                                                                                                                                                                            	// match.
                                                                                                                                                                                                                                                                            	OutlineColor DvbSubDestinationOutlineColor
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies font outline size in pixels. This option is not valid for source
                                                                                                                                                                                                                                                                            	// captions that are either 608/embedded or teletext. These source settings are
                                                                                                                                                                                                                                                                            	// already pre-defined by the caption stream. All burn-in and DVB-Sub font settings
                                                                                                                                                                                                                                                                            	// must match.
                                                                                                                                                                                                                                                                            	OutlineSize int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the color of the shadow cast by the captions. All burn-in and DVB-Sub
                                                                                                                                                                                                                                                                            	// font settings must match.
                                                                                                                                                                                                                                                                            	ShadowColor DvbSubDestinationShadowColor
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the opacity of the shadow. 255 is opaque; 0 is transparent. Leaving
                                                                                                                                                                                                                                                                            	// this parameter blank is equivalent to setting it to 0 (transparent). All burn-in
                                                                                                                                                                                                                                                                            	// and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	ShadowOpacity int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the horizontal offset of the shadow relative to the captions in
                                                                                                                                                                                                                                                                            	// pixels. A value of -2 would result in a shadow offset 2 pixels to the left. All
                                                                                                                                                                                                                                                                            	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	ShadowXOffset int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the vertical offset of the shadow relative to the captions in pixels.
                                                                                                                                                                                                                                                                            	// A value of -2 would result in a shadow offset 2 pixels above the text. All
                                                                                                                                                                                                                                                                            	// burn-in and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	ShadowYOffset int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Controls whether a fixed grid size will be used to generate the output subtitles
                                                                                                                                                                                                                                                                            	// bitmap. Only applicable for Teletext inputs and DVB-Sub/Burn-in outputs.
                                                                                                                                                                                                                                                                            	TeletextGridControl DvbSubDestinationTeletextGridControl
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the horizontal position of the caption relative to the left side of
                                                                                                                                                                                                                                                                            	// the output in pixels. A value of 10 would result in the captions starting 10
                                                                                                                                                                                                                                                                            	// pixels from the left of the output. If no explicit xPosition is provided, the
                                                                                                                                                                                                                                                                            	// horizontal caption position will be determined by the alignment parameter. This
                                                                                                                                                                                                                                                                            	// option is not valid for source captions that are STL, 608/embedded or teletext.
                                                                                                                                                                                                                                                                            	// These source settings are already pre-defined by the caption stream. All burn-in
                                                                                                                                                                                                                                                                            	// and DVB-Sub font settings must match.
                                                                                                                                                                                                                                                                            	XPosition int32
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// Specifies the vertical position of the caption relative to the top of the output
                                                                                                                                                                                                                                                                            	// in pixels. A value of 10 would result in the captions starting 10 pixels from
                                                                                                                                                                                                                                                                            	// the top of the output. If no explicit yPosition is provided, the caption will be
                                                                                                                                                                                                                                                                            	// positioned towards the bottom of the output. This option is not valid for source
                                                                                                                                                                                                                                                                            	// captions that are STL, 608/embedded or teletext. These source settings are
                                                                                                                                                                                                                                                                            	// already pre-defined by the caption stream. All burn-in and DVB-Sub font settings
                                                                                                                                                                                                                                                                            	// must match.
                                                                                                                                                                                                                                                                            	YPosition int32
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              Dvb Sub Destination Settings

                                                                                                                                                                                                                                                                              type DvbSubDestinationShadowColor

                                                                                                                                                                                                                                                                              type DvbSubDestinationShadowColor string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	DvbSubDestinationShadowColorBlack DvbSubDestinationShadowColor = "BLACK"
                                                                                                                                                                                                                                                                              	DvbSubDestinationShadowColorNone  DvbSubDestinationShadowColor = "NONE"
                                                                                                                                                                                                                                                                              	DvbSubDestinationShadowColorWhite DvbSubDestinationShadowColor = "WHITE"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for DvbSubDestinationShadowColor

                                                                                                                                                                                                                                                                                func (DvbSubDestinationShadowColor) Values

                                                                                                                                                                                                                                                                                  Values returns all known values for DvbSubDestinationShadowColor. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                  type DvbSubDestinationTeletextGridControl

                                                                                                                                                                                                                                                                                  type DvbSubDestinationTeletextGridControl string
                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                  	DvbSubDestinationTeletextGridControlFixed  DvbSubDestinationTeletextGridControl = "FIXED"
                                                                                                                                                                                                                                                                                  	DvbSubDestinationTeletextGridControlScaled DvbSubDestinationTeletextGridControl = "SCALED"
                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                    Enum values for DvbSubDestinationTeletextGridControl

                                                                                                                                                                                                                                                                                    func (DvbSubDestinationTeletextGridControl) Values

                                                                                                                                                                                                                                                                                      Values returns all known values for DvbSubDestinationTeletextGridControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                      type DvbSubSourceSettings

                                                                                                                                                                                                                                                                                      type DvbSubSourceSettings struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// When using DVB-Sub with Burn-In or SMPTE-TT, use this PID for the source
                                                                                                                                                                                                                                                                                      	// content. Unused for DVB-Sub passthrough. All DVB-Sub content is passed through,
                                                                                                                                                                                                                                                                                      	// regardless of selectors.
                                                                                                                                                                                                                                                                                      	Pid int32
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Dvb Sub Source Settings

                                                                                                                                                                                                                                                                                        type DvbTdtSettings

                                                                                                                                                                                                                                                                                        type DvbTdtSettings struct {
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The number of milliseconds between instances of this table in the output
                                                                                                                                                                                                                                                                                        	// transport stream.
                                                                                                                                                                                                                                                                                        	RepInterval int32
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          DVB Time and Date Table (SDT)

                                                                                                                                                                                                                                                                                          type Eac3AttenuationControl

                                                                                                                                                                                                                                                                                          type Eac3AttenuationControl string
                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                          	Eac3AttenuationControlAttenuate3Db Eac3AttenuationControl = "ATTENUATE_3_DB"
                                                                                                                                                                                                                                                                                          	Eac3AttenuationControlNone         Eac3AttenuationControl = "NONE"
                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                            Enum values for Eac3AttenuationControl

                                                                                                                                                                                                                                                                                            func (Eac3AttenuationControl) Values

                                                                                                                                                                                                                                                                                              Values returns all known values for Eac3AttenuationControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                              type Eac3BitstreamMode

                                                                                                                                                                                                                                                                                              type Eac3BitstreamMode string
                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                              	Eac3BitstreamModeCommentary       Eac3BitstreamMode = "COMMENTARY"
                                                                                                                                                                                                                                                                                              	Eac3BitstreamModeCompleteMain     Eac3BitstreamMode = "COMPLETE_MAIN"
                                                                                                                                                                                                                                                                                              	Eac3BitstreamModeEmergency        Eac3BitstreamMode = "EMERGENCY"
                                                                                                                                                                                                                                                                                              	Eac3BitstreamModeHearingImpaired  Eac3BitstreamMode = "HEARING_IMPAIRED"
                                                                                                                                                                                                                                                                                              	Eac3BitstreamModeVisuallyImpaired Eac3BitstreamMode = "VISUALLY_IMPAIRED"
                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                Enum values for Eac3BitstreamMode

                                                                                                                                                                                                                                                                                                func (Eac3BitstreamMode) Values

                                                                                                                                                                                                                                                                                                  Values returns all known values for Eac3BitstreamMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                  type Eac3CodingMode

                                                                                                                                                                                                                                                                                                  type Eac3CodingMode string
                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                  	Eac3CodingModeCodingMode10 Eac3CodingMode = "CODING_MODE_1_0"
                                                                                                                                                                                                                                                                                                  	Eac3CodingModeCodingMode20 Eac3CodingMode = "CODING_MODE_2_0"
                                                                                                                                                                                                                                                                                                  	Eac3CodingModeCodingMode32 Eac3CodingMode = "CODING_MODE_3_2"
                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                    Enum values for Eac3CodingMode

                                                                                                                                                                                                                                                                                                    func (Eac3CodingMode) Values

                                                                                                                                                                                                                                                                                                    func (Eac3CodingMode) Values() []Eac3CodingMode

                                                                                                                                                                                                                                                                                                      Values returns all known values for Eac3CodingMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                      type Eac3DcFilter

                                                                                                                                                                                                                                                                                                      type Eac3DcFilter string
                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                      	Eac3DcFilterDisabled Eac3DcFilter = "DISABLED"
                                                                                                                                                                                                                                                                                                      	Eac3DcFilterEnabled  Eac3DcFilter = "ENABLED"
                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                        Enum values for Eac3DcFilter

                                                                                                                                                                                                                                                                                                        func (Eac3DcFilter) Values

                                                                                                                                                                                                                                                                                                        func (Eac3DcFilter) Values() []Eac3DcFilter

                                                                                                                                                                                                                                                                                                          Values returns all known values for Eac3DcFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                          type Eac3DrcLine

                                                                                                                                                                                                                                                                                                          type Eac3DrcLine string
                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineFilmLight     Eac3DrcLine = "FILM_LIGHT"
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineFilmStandard  Eac3DrcLine = "FILM_STANDARD"
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineMusicLight    Eac3DrcLine = "MUSIC_LIGHT"
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineMusicStandard Eac3DrcLine = "MUSIC_STANDARD"
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineNone          Eac3DrcLine = "NONE"
                                                                                                                                                                                                                                                                                                          	Eac3DrcLineSpeech        Eac3DrcLine = "SPEECH"
                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                            Enum values for Eac3DrcLine

                                                                                                                                                                                                                                                                                                            func (Eac3DrcLine) Values

                                                                                                                                                                                                                                                                                                            func (Eac3DrcLine) Values() []Eac3DrcLine

                                                                                                                                                                                                                                                                                                              Values returns all known values for Eac3DrcLine. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                              type Eac3DrcRf

                                                                                                                                                                                                                                                                                                              type Eac3DrcRf string
                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfFilmLight     Eac3DrcRf = "FILM_LIGHT"
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfFilmStandard  Eac3DrcRf = "FILM_STANDARD"
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfMusicLight    Eac3DrcRf = "MUSIC_LIGHT"
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfMusicStandard Eac3DrcRf = "MUSIC_STANDARD"
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfNone          Eac3DrcRf = "NONE"
                                                                                                                                                                                                                                                                                                              	Eac3DrcRfSpeech        Eac3DrcRf = "SPEECH"
                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                Enum values for Eac3DrcRf

                                                                                                                                                                                                                                                                                                                func (Eac3DrcRf) Values

                                                                                                                                                                                                                                                                                                                func (Eac3DrcRf) Values() []Eac3DrcRf

                                                                                                                                                                                                                                                                                                                  Values returns all known values for Eac3DrcRf. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                  type Eac3LfeControl

                                                                                                                                                                                                                                                                                                                  type Eac3LfeControl string
                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                  	Eac3LfeControlLfe   Eac3LfeControl = "LFE"
                                                                                                                                                                                                                                                                                                                  	Eac3LfeControlNoLfe Eac3LfeControl = "NO_LFE"
                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                    Enum values for Eac3LfeControl

                                                                                                                                                                                                                                                                                                                    func (Eac3LfeControl) Values

                                                                                                                                                                                                                                                                                                                    func (Eac3LfeControl) Values() []Eac3LfeControl

                                                                                                                                                                                                                                                                                                                      Values returns all known values for Eac3LfeControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                      type Eac3LfeFilter

                                                                                                                                                                                                                                                                                                                      type Eac3LfeFilter string
                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                      	Eac3LfeFilterDisabled Eac3LfeFilter = "DISABLED"
                                                                                                                                                                                                                                                                                                                      	Eac3LfeFilterEnabled  Eac3LfeFilter = "ENABLED"
                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                        Enum values for Eac3LfeFilter

                                                                                                                                                                                                                                                                                                                        func (Eac3LfeFilter) Values

                                                                                                                                                                                                                                                                                                                        func (Eac3LfeFilter) Values() []Eac3LfeFilter

                                                                                                                                                                                                                                                                                                                          Values returns all known values for Eac3LfeFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                          type Eac3MetadataControl

                                                                                                                                                                                                                                                                                                                          type Eac3MetadataControl string
                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                          	Eac3MetadataControlFollowInput   Eac3MetadataControl = "FOLLOW_INPUT"
                                                                                                                                                                                                                                                                                                                          	Eac3MetadataControlUseConfigured Eac3MetadataControl = "USE_CONFIGURED"
                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                            Enum values for Eac3MetadataControl

                                                                                                                                                                                                                                                                                                                            func (Eac3MetadataControl) Values

                                                                                                                                                                                                                                                                                                                              Values returns all known values for Eac3MetadataControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                              type Eac3PassthroughControl

                                                                                                                                                                                                                                                                                                                              type Eac3PassthroughControl string
                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                              	Eac3PassthroughControlNoPassthrough Eac3PassthroughControl = "NO_PASSTHROUGH"
                                                                                                                                                                                                                                                                                                                              	Eac3PassthroughControlWhenPossible  Eac3PassthroughControl = "WHEN_POSSIBLE"
                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                Enum values for Eac3PassthroughControl

                                                                                                                                                                                                                                                                                                                                func (Eac3PassthroughControl) Values

                                                                                                                                                                                                                                                                                                                                  Values returns all known values for Eac3PassthroughControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                  type Eac3PhaseControl

                                                                                                                                                                                                                                                                                                                                  type Eac3PhaseControl string
                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                  	Eac3PhaseControlNoShift        Eac3PhaseControl = "NO_SHIFT"
                                                                                                                                                                                                                                                                                                                                  	Eac3PhaseControlShift90Degrees Eac3PhaseControl = "SHIFT_90_DEGREES"
                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                    Enum values for Eac3PhaseControl

                                                                                                                                                                                                                                                                                                                                    func (Eac3PhaseControl) Values

                                                                                                                                                                                                                                                                                                                                      Values returns all known values for Eac3PhaseControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                      type Eac3Settings

                                                                                                                                                                                                                                                                                                                                      type Eac3Settings struct {
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to attenuate3Db, applies a 3 dB attenuation to the surround channels.
                                                                                                                                                                                                                                                                                                                                      	// Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	AttenuationControl Eac3AttenuationControl
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Average bitrate in bits/second. Valid bitrates depend on the coding mode.
                                                                                                                                                                                                                                                                                                                                      	Bitrate float64
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Specifies the bitstream mode (bsmod) for the emitted E-AC-3 stream. See ATSC
                                                                                                                                                                                                                                                                                                                                      	// A/52-2012 (Annex E) for background on these values.
                                                                                                                                                                                                                                                                                                                                      	BitstreamMode Eac3BitstreamMode
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Dolby Digital Plus coding mode. Determines number of channels.
                                                                                                                                                                                                                                                                                                                                      	CodingMode Eac3CodingMode
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to enabled, activates a DC highpass filter for all input channels.
                                                                                                                                                                                                                                                                                                                                      	DcFilter Eac3DcFilter
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Sets the dialnorm for the output. If blank and input audio is Dolby Digital
                                                                                                                                                                                                                                                                                                                                      	// Plus, dialnorm will be passed through.
                                                                                                                                                                                                                                                                                                                                      	Dialnorm int32
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Sets the Dolby dynamic range compression profile.
                                                                                                                                                                                                                                                                                                                                      	DrcLine Eac3DrcLine
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Sets the profile for heavy Dolby dynamic range compression, ensures that the
                                                                                                                                                                                                                                                                                                                                      	// instantaneous signal peaks do not exceed specified levels.
                                                                                                                                                                                                                                                                                                                                      	DrcRf Eac3DrcRf
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When encoding 3/2 audio, setting to lfe enables the LFE channel
                                                                                                                                                                                                                                                                                                                                      	LfeControl Eac3LfeControl
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to enabled, applies a 120Hz lowpass filter to the LFE channel prior to
                                                                                                                                                                                                                                                                                                                                      	// encoding. Only valid with codingMode32 coding mode.
                                                                                                                                                                                                                                                                                                                                      	LfeFilter Eac3LfeFilter
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Left only/Right only center mix level. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	LoRoCenterMixLevel float64
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Left only/Right only surround mix level. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	LoRoSurroundMixLevel float64
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Left total/Right total center mix level. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	LtRtCenterMixLevel float64
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Left total/Right total surround mix level. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	LtRtSurroundMixLevel float64
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to followInput, encoder metadata will be sourced from the DD, DD+, or
                                                                                                                                                                                                                                                                                                                                      	// DolbyE decoder that supplied this audio data. If audio was not supplied from one
                                                                                                                                                                                                                                                                                                                                      	// of these streams, then the static metadata settings will be used.
                                                                                                                                                                                                                                                                                                                                      	MetadataControl Eac3MetadataControl
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to whenPossible, input DD+ audio will be passed through if it is
                                                                                                                                                                                                                                                                                                                                      	// present on the input. This detection is dynamic over the life of the transcode.
                                                                                                                                                                                                                                                                                                                                      	// Inputs that alternate between DD+ and non-DD+ content will have a consistent DD+
                                                                                                                                                                                                                                                                                                                                      	// output as the system alternates between passthrough and encoding.
                                                                                                                                                                                                                                                                                                                                      	PassthroughControl Eac3PassthroughControl
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When set to shift90Degrees, applies a 90-degree phase shift to the surround
                                                                                                                                                                                                                                                                                                                                      	// channels. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	PhaseControl Eac3PhaseControl
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Stereo downmix preference. Only used for 3/2 coding mode.
                                                                                                                                                                                                                                                                                                                                      	StereoDownmix Eac3StereoDownmix
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When encoding 3/2 audio, sets whether an extra center back surround channel is
                                                                                                                                                                                                                                                                                                                                      	// matrix encoded into the left and right surround channels.
                                                                                                                                                                                                                                                                                                                                      	SurroundExMode Eac3SurroundExMode
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// When encoding 2/0 audio, sets whether Dolby Surround is matrix encoded into the
                                                                                                                                                                                                                                                                                                                                      	// two channels.
                                                                                                                                                                                                                                                                                                                                      	SurroundMode Eac3SurroundMode
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        Eac3 Settings

                                                                                                                                                                                                                                                                                                                                        type Eac3StereoDownmix

                                                                                                                                                                                                                                                                                                                                        type Eac3StereoDownmix string
                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                        	Eac3StereoDownmixDpl2         Eac3StereoDownmix = "DPL2"
                                                                                                                                                                                                                                                                                                                                        	Eac3StereoDownmixLoRo         Eac3StereoDownmix = "LO_RO"
                                                                                                                                                                                                                                                                                                                                        	Eac3StereoDownmixLtRt         Eac3StereoDownmix = "LT_RT"
                                                                                                                                                                                                                                                                                                                                        	Eac3StereoDownmixNotIndicated Eac3StereoDownmix = "NOT_INDICATED"
                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                          Enum values for Eac3StereoDownmix

                                                                                                                                                                                                                                                                                                                                          func (Eac3StereoDownmix) Values

                                                                                                                                                                                                                                                                                                                                            Values returns all known values for Eac3StereoDownmix. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                            type Eac3SurroundExMode

                                                                                                                                                                                                                                                                                                                                            type Eac3SurroundExMode string
                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                            	Eac3SurroundExModeDisabled     Eac3SurroundExMode = "DISABLED"
                                                                                                                                                                                                                                                                                                                                            	Eac3SurroundExModeEnabled      Eac3SurroundExMode = "ENABLED"
                                                                                                                                                                                                                                                                                                                                            	Eac3SurroundExModeNotIndicated Eac3SurroundExMode = "NOT_INDICATED"
                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                              Enum values for Eac3SurroundExMode

                                                                                                                                                                                                                                                                                                                                              func (Eac3SurroundExMode) Values

                                                                                                                                                                                                                                                                                                                                                Values returns all known values for Eac3SurroundExMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                type Eac3SurroundMode

                                                                                                                                                                                                                                                                                                                                                type Eac3SurroundMode string
                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                	Eac3SurroundModeDisabled     Eac3SurroundMode = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                	Eac3SurroundModeEnabled      Eac3SurroundMode = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                	Eac3SurroundModeNotIndicated Eac3SurroundMode = "NOT_INDICATED"
                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                  Enum values for Eac3SurroundMode

                                                                                                                                                                                                                                                                                                                                                  func (Eac3SurroundMode) Values

                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for Eac3SurroundMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                    type EbuTtDDestinationSettings

                                                                                                                                                                                                                                                                                                                                                    type EbuTtDDestinationSettings struct {
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// Specifies how to handle the gap between the lines (in multi-line captions).
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                    	// enabled: Fill with the captions background color (as specified in the input
                                                                                                                                                                                                                                                                                                                                                    	// captions).
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * disabled: Leave the gap unfilled.
                                                                                                                                                                                                                                                                                                                                                    	FillLineGap EbuTtDFillLineGapControl
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// Specifies the font family to include in the font data attached to the EBU-TT
                                                                                                                                                                                                                                                                                                                                                    	// captions. Valid only if styleControl is set to include. If you leave this field
                                                                                                                                                                                                                                                                                                                                                    	// empty, the font family is set to "monospaced". (If styleControl is set to
                                                                                                                                                                                                                                                                                                                                                    	// exclude, the font family is always set to "monospaced".) You specify only the
                                                                                                                                                                                                                                                                                                                                                    	// font family. All other style information (color, bold, position and so on) is
                                                                                                                                                                                                                                                                                                                                                    	// copied from the input captions. The size is always set to 100% to allow the
                                                                                                                                                                                                                                                                                                                                                    	// downstream player to choose the size.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * Enter a list of font families, as a
                                                                                                                                                                                                                                                                                                                                                    	// comma-separated list of font names, in order of preference. The name can be a
                                                                                                                                                                                                                                                                                                                                                    	// font family (such as “Arial”), or a generic font family (such as “serif”), or
                                                                                                                                                                                                                                                                                                                                                    	// “default” (to let the downstream player choose the font).
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * Leave blank to set
                                                                                                                                                                                                                                                                                                                                                    	// the family to “monospace”.
                                                                                                                                                                                                                                                                                                                                                    	FontFamily *string
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// Specifies the style information (font color, font position, and so on) to
                                                                                                                                                                                                                                                                                                                                                    	// include in the font data that is attached to the EBU-TT captions.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * include:
                                                                                                                                                                                                                                                                                                                                                    	// Take the style information (font color, font position, and so on) from the
                                                                                                                                                                                                                                                                                                                                                    	// source captions and include that information in the font data attached to the
                                                                                                                                                                                                                                                                                                                                                    	// EBU-TT captions. This option is valid only if the source captions are Embedded
                                                                                                                                                                                                                                                                                                                                                    	// or Teletext.
                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                    	// * exclude: In the font data attached to the EBU-TT captions, set
                                                                                                                                                                                                                                                                                                                                                    	// the font family to "monospaced". Do not include any other style information.
                                                                                                                                                                                                                                                                                                                                                    	StyleControl EbuTtDDestinationStyleControl
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      Ebu Tt DDestination Settings

                                                                                                                                                                                                                                                                                                                                                      type EbuTtDDestinationStyleControl

                                                                                                                                                                                                                                                                                                                                                      type EbuTtDDestinationStyleControl string
                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                      	EbuTtDDestinationStyleControlExclude EbuTtDDestinationStyleControl = "EXCLUDE"
                                                                                                                                                                                                                                                                                                                                                      	EbuTtDDestinationStyleControlInclude EbuTtDDestinationStyleControl = "INCLUDE"
                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                        Enum values for EbuTtDDestinationStyleControl

                                                                                                                                                                                                                                                                                                                                                        func (EbuTtDDestinationStyleControl) Values

                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for EbuTtDDestinationStyleControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                          type EbuTtDFillLineGapControl

                                                                                                                                                                                                                                                                                                                                                          type EbuTtDFillLineGapControl string
                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                          	EbuTtDFillLineGapControlDisabled EbuTtDFillLineGapControl = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                          	EbuTtDFillLineGapControlEnabled  EbuTtDFillLineGapControl = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                            Enum values for EbuTtDFillLineGapControl

                                                                                                                                                                                                                                                                                                                                                            func (EbuTtDFillLineGapControl) Values

                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for EbuTtDFillLineGapControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                              type EmbeddedConvert608To708

                                                                                                                                                                                                                                                                                                                                                              type EmbeddedConvert608To708 string
                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                              	EmbeddedConvert608To708Disabled  EmbeddedConvert608To708 = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                              	EmbeddedConvert608To708Upconvert EmbeddedConvert608To708 = "UPCONVERT"
                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                Enum values for EmbeddedConvert608To708

                                                                                                                                                                                                                                                                                                                                                                func (EmbeddedConvert608To708) Values

                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for EmbeddedConvert608To708. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                  type EmbeddedDestinationSettings

                                                                                                                                                                                                                                                                                                                                                                  type EmbeddedDestinationSettings struct {
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    Embedded Destination Settings

                                                                                                                                                                                                                                                                                                                                                                    type EmbeddedPlusScte20DestinationSettings

                                                                                                                                                                                                                                                                                                                                                                    type EmbeddedPlusScte20DestinationSettings struct {
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      Embedded Plus Scte20 Destination Settings

                                                                                                                                                                                                                                                                                                                                                                      type EmbeddedScte20Detection

                                                                                                                                                                                                                                                                                                                                                                      type EmbeddedScte20Detection string
                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                      	EmbeddedScte20DetectionAuto EmbeddedScte20Detection = "AUTO"
                                                                                                                                                                                                                                                                                                                                                                      	EmbeddedScte20DetectionOff  EmbeddedScte20Detection = "OFF"
                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                        Enum values for EmbeddedScte20Detection

                                                                                                                                                                                                                                                                                                                                                                        func (EmbeddedScte20Detection) Values

                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for EmbeddedScte20Detection. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                          type EmbeddedSourceSettings

                                                                                                                                                                                                                                                                                                                                                                          type EmbeddedSourceSettings struct {
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// If upconvert, 608 data is both passed through via the "608 compatibility bytes"
                                                                                                                                                                                                                                                                                                                                                                          	// fields of the 708 wrapper as well as translated into 708. 708 data present in
                                                                                                                                                                                                                                                                                                                                                                          	// the source content will be discarded.
                                                                                                                                                                                                                                                                                                                                                                          	Convert608To708 EmbeddedConvert608To708
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Set to "auto" to handle streams with intermittent and/or non-aligned SCTE-20 and
                                                                                                                                                                                                                                                                                                                                                                          	// Embedded captions.
                                                                                                                                                                                                                                                                                                                                                                          	Scte20Detection EmbeddedScte20Detection
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// Specifies the 608/708 channel number within the video track from which to
                                                                                                                                                                                                                                                                                                                                                                          	// extract captions. Unused for passthrough.
                                                                                                                                                                                                                                                                                                                                                                          	Source608ChannelNumber int32
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// This field is unused and deprecated.
                                                                                                                                                                                                                                                                                                                                                                          	Source608TrackNumber int32
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Embedded Source Settings

                                                                                                                                                                                                                                                                                                                                                                            type EncoderSettings

                                                                                                                                                                                                                                                                                                                                                                            type EncoderSettings struct {
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Placeholder documentation for __listOfAudioDescription
                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                            	AudioDescriptions []AudioDescription
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Placeholder documentation for __listOfOutputGroup
                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                            	OutputGroups []OutputGroup
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Contains settings used to acquire and adjust timecode information from inputs.
                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                            	TimecodeConfig *TimecodeConfig
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Placeholder documentation for __listOfVideoDescription
                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                            	VideoDescriptions []VideoDescription
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Settings for ad avail blanking.
                                                                                                                                                                                                                                                                                                                                                                            	AvailBlanking *AvailBlanking
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Event-wide configuration settings for ad avail insertion.
                                                                                                                                                                                                                                                                                                                                                                            	AvailConfiguration *AvailConfiguration
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Settings for blackout slate.
                                                                                                                                                                                                                                                                                                                                                                            	BlackoutSlate *BlackoutSlate
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Settings for caption decriptions
                                                                                                                                                                                                                                                                                                                                                                            	CaptionDescriptions []CaptionDescription
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Feature Activations
                                                                                                                                                                                                                                                                                                                                                                            	FeatureActivations *FeatureActivations
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Configuration settings that apply to the event as a whole.
                                                                                                                                                                                                                                                                                                                                                                            	GlobalConfiguration *GlobalConfiguration
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// Nielsen configuration settings.
                                                                                                                                                                                                                                                                                                                                                                            	NielsenConfiguration *NielsenConfiguration
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              Encoder Settings

                                                                                                                                                                                                                                                                                                                                                                              type FailoverCondition

                                                                                                                                                                                                                                                                                                                                                                              type FailoverCondition struct {
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// Failover condition type-specific settings.
                                                                                                                                                                                                                                                                                                                                                                              	FailoverConditionSettings *FailoverConditionSettings
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                Failover Condition settings. There can be multiple failover conditions inside AutomaticInputFailoverSettings.

                                                                                                                                                                                                                                                                                                                                                                                type FailoverConditionSettings

                                                                                                                                                                                                                                                                                                                                                                                type FailoverConditionSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// MediaLive will perform a failover if the specified audio selector is silent for
                                                                                                                                                                                                                                                                                                                                                                                	// the specified period.
                                                                                                                                                                                                                                                                                                                                                                                	AudioSilenceSettings *AudioSilenceFailoverSettings
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// MediaLive will perform a failover if content is not detected in this input for
                                                                                                                                                                                                                                                                                                                                                                                	// the specified period.
                                                                                                                                                                                                                                                                                                                                                                                	InputLossSettings *InputLossFailoverSettings
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// MediaLive will perform a failover if content is considered black for the
                                                                                                                                                                                                                                                                                                                                                                                	// specified period.
                                                                                                                                                                                                                                                                                                                                                                                	VideoBlackSettings *VideoBlackFailoverSettings
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  Settings for one failover condition.

                                                                                                                                                                                                                                                                                                                                                                                  type FeatureActivations

                                                                                                                                                                                                                                                                                                                                                                                  type FeatureActivations struct {
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// Enables the Input Prepare feature. You can create Input Prepare actions in the
                                                                                                                                                                                                                                                                                                                                                                                  	// schedule only if this feature is enabled. If you disable the feature on an
                                                                                                                                                                                                                                                                                                                                                                                  	// existing schedule, make sure that you first delete all input prepare actions
                                                                                                                                                                                                                                                                                                                                                                                  	// from the schedule.
                                                                                                                                                                                                                                                                                                                                                                                  	InputPrepareScheduleActions FeatureActivationsInputPrepareScheduleActions
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    Feature Activations

                                                                                                                                                                                                                                                                                                                                                                                    type FeatureActivationsInputPrepareScheduleActions

                                                                                                                                                                                                                                                                                                                                                                                    type FeatureActivationsInputPrepareScheduleActions string
                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                    	FeatureActivationsInputPrepareScheduleActionsDisabled FeatureActivationsInputPrepareScheduleActions = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                    	FeatureActivationsInputPrepareScheduleActionsEnabled  FeatureActivationsInputPrepareScheduleActions = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                      Enum values for FeatureActivationsInputPrepareScheduleActions

                                                                                                                                                                                                                                                                                                                                                                                      func (FeatureActivationsInputPrepareScheduleActions) Values

                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for FeatureActivationsInputPrepareScheduleActions. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                        type FecOutputIncludeFec

                                                                                                                                                                                                                                                                                                                                                                                        type FecOutputIncludeFec string
                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                        	FecOutputIncludeFecColumn       FecOutputIncludeFec = "COLUMN"
                                                                                                                                                                                                                                                                                                                                                                                        	FecOutputIncludeFecColumnAndRow FecOutputIncludeFec = "COLUMN_AND_ROW"
                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                          Enum values for FecOutputIncludeFec

                                                                                                                                                                                                                                                                                                                                                                                          func (FecOutputIncludeFec) Values

                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for FecOutputIncludeFec. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                            type FecOutputSettings

                                                                                                                                                                                                                                                                                                                                                                                            type FecOutputSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// Parameter D from SMPTE 2022-1. The height of the FEC protection matrix. The
                                                                                                                                                                                                                                                                                                                                                                                            	// number of transport stream packets per column error correction packet. Must be
                                                                                                                                                                                                                                                                                                                                                                                            	// between 4 and 20, inclusive.
                                                                                                                                                                                                                                                                                                                                                                                            	ColumnDepth int32
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// Enables column only or column and row based FEC
                                                                                                                                                                                                                                                                                                                                                                                            	IncludeFec FecOutputIncludeFec
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// Parameter L from SMPTE 2022-1. The width of the FEC protection matrix. Must be
                                                                                                                                                                                                                                                                                                                                                                                            	// between 1 and 20, inclusive. If only Column FEC is used, then larger values
                                                                                                                                                                                                                                                                                                                                                                                            	// increase robustness. If Row FEC is used, then this is the number of transport
                                                                                                                                                                                                                                                                                                                                                                                            	// stream packets per row error correction packet, and the value must be between 4
                                                                                                                                                                                                                                                                                                                                                                                            	// and 20, inclusive, if includeFec is columnAndRow. If includeFec is column, this
                                                                                                                                                                                                                                                                                                                                                                                            	// value must be 1 to 20, inclusive.
                                                                                                                                                                                                                                                                                                                                                                                            	RowLength int32
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              Fec Output Settings

                                                                                                                                                                                                                                                                                                                                                                                              type FixedAfd

                                                                                                                                                                                                                                                                                                                                                                                              type FixedAfd string
                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd0000 FixedAfd = "AFD_0000"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd0010 FixedAfd = "AFD_0010"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd0011 FixedAfd = "AFD_0011"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd0100 FixedAfd = "AFD_0100"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1000 FixedAfd = "AFD_1000"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1001 FixedAfd = "AFD_1001"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1010 FixedAfd = "AFD_1010"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1011 FixedAfd = "AFD_1011"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1101 FixedAfd = "AFD_1101"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1110 FixedAfd = "AFD_1110"
                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfdAfd1111 FixedAfd = "AFD_1111"
                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                Enum values for FixedAfd

                                                                                                                                                                                                                                                                                                                                                                                                func (FixedAfd) Values

                                                                                                                                                                                                                                                                                                                                                                                                func (FixedAfd) Values() []FixedAfd

                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for FixedAfd. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                  type FixedModeScheduleActionStartSettings

                                                                                                                                                                                                                                                                                                                                                                                                  type FixedModeScheduleActionStartSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Start time for the action to start in the channel. (Not the time for the action
                                                                                                                                                                                                                                                                                                                                                                                                  	// to be added to the schedule: actions are always added to the schedule
                                                                                                                                                                                                                                                                                                                                                                                                  	// immediately.) UTC format: yyyy-mm-ddThh:mm:ss.nnnZ. All the letters are digits
                                                                                                                                                                                                                                                                                                                                                                                                  	// (for example, mm might be 01) except for the two constants "T" for time and "Z"
                                                                                                                                                                                                                                                                                                                                                                                                  	// for "UTC format".
                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                  	Time *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    Start time for the action.

                                                                                                                                                                                                                                                                                                                                                                                                    type Fmp4HlsSettings

                                                                                                                                                                                                                                                                                                                                                                                                    type Fmp4HlsSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// List all the audio groups that are used with the video output stream. Input all
                                                                                                                                                                                                                                                                                                                                                                                                    	// the audio GROUP-IDs that are associated to the video, separate by ','.
                                                                                                                                                                                                                                                                                                                                                                                                    	AudioRenditionSets *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// If set to passthrough, Nielsen inaudible tones for media tracking will be
                                                                                                                                                                                                                                                                                                                                                                                                    	// detected in the input audio and an equivalent ID3 tag will be inserted in the
                                                                                                                                                                                                                                                                                                                                                                                                    	// output.
                                                                                                                                                                                                                                                                                                                                                                                                    	NielsenId3Behavior Fmp4NielsenId3Behavior
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// When set to passthrough, timed metadata is passed through from input to output.
                                                                                                                                                                                                                                                                                                                                                                                                    	TimedMetadataBehavior Fmp4TimedMetadataBehavior
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      Fmp4 Hls Settings

                                                                                                                                                                                                                                                                                                                                                                                                      type Fmp4NielsenId3Behavior

                                                                                                                                                                                                                                                                                                                                                                                                      type Fmp4NielsenId3Behavior string
                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                      	Fmp4NielsenId3BehaviorNoPassthrough Fmp4NielsenId3Behavior = "NO_PASSTHROUGH"
                                                                                                                                                                                                                                                                                                                                                                                                      	Fmp4NielsenId3BehaviorPassthrough   Fmp4NielsenId3Behavior = "PASSTHROUGH"
                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for Fmp4NielsenId3Behavior

                                                                                                                                                                                                                                                                                                                                                                                                        func (Fmp4NielsenId3Behavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for Fmp4NielsenId3Behavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                          type Fmp4TimedMetadataBehavior

                                                                                                                                                                                                                                                                                                                                                                                                          type Fmp4TimedMetadataBehavior string
                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                          	Fmp4TimedMetadataBehaviorNoPassthrough Fmp4TimedMetadataBehavior = "NO_PASSTHROUGH"
                                                                                                                                                                                                                                                                                                                                                                                                          	Fmp4TimedMetadataBehaviorPassthrough   Fmp4TimedMetadataBehavior = "PASSTHROUGH"
                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for Fmp4TimedMetadataBehavior

                                                                                                                                                                                                                                                                                                                                                                                                            func (Fmp4TimedMetadataBehavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for Fmp4TimedMetadataBehavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                              type FollowModeScheduleActionStartSettings

                                                                                                                                                                                                                                                                                                                                                                                                              type FollowModeScheduleActionStartSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// Identifies whether this action starts relative to the start or relative to the
                                                                                                                                                                                                                                                                                                                                                                                                              	// end of the reference action.
                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                              	FollowPoint FollowPoint
                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                              	// The action name of another action that this one refers to.
                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                              	ReferenceActionName *string
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                Settings to specify if an action follows another.

                                                                                                                                                                                                                                                                                                                                                                                                                type FollowPoint

                                                                                                                                                                                                                                                                                                                                                                                                                type FollowPoint string
                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                	FollowPointEnd   FollowPoint = "END"
                                                                                                                                                                                                                                                                                                                                                                                                                	FollowPointStart FollowPoint = "START"
                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for FollowPoint

                                                                                                                                                                                                                                                                                                                                                                                                                  func (FollowPoint) Values

                                                                                                                                                                                                                                                                                                                                                                                                                  func (FollowPoint) Values() []FollowPoint

                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for FollowPoint. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                    type ForbiddenException

                                                                                                                                                                                                                                                                                                                                                                                                                    type ForbiddenException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      Placeholder documentation for ForbiddenException

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ForbiddenException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ForbiddenException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ForbiddenException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ForbiddenException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ForbiddenException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ForbiddenException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ForbiddenException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                      func (e *ForbiddenException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                      type FrameCaptureGroupSettings

                                                                                                                                                                                                                                                                                                                                                                                                                      type FrameCaptureGroupSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                      	// The destination for the frame capture files. Either the URI for an Amazon S3
                                                                                                                                                                                                                                                                                                                                                                                                                      	// bucket and object, plus a file name prefix (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                      	// s3ssl://sportsDelivery/highlights/20180820/curling-) or the URI for a MediaStore
                                                                                                                                                                                                                                                                                                                                                                                                                      	// container, plus a file name prefix (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                      	// mediastoressl://sportsDelivery/20180820/curling-). The final file names consist
                                                                                                                                                                                                                                                                                                                                                                                                                      	// of the prefix from the destination field (for example, "curling-") + name
                                                                                                                                                                                                                                                                                                                                                                                                                      	// modifier + the counter (5 digits, starting from 00001) + extension (which is
                                                                                                                                                                                                                                                                                                                                                                                                                      	// always .jpg). For example, curling-low.00001.jpg
                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                      	Destination *OutputLocationRef
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        Frame Capture Group Settings

                                                                                                                                                                                                                                                                                                                                                                                                                        type FrameCaptureIntervalUnit

                                                                                                                                                                                                                                                                                                                                                                                                                        type FrameCaptureIntervalUnit string
                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                        	FrameCaptureIntervalUnitMilliseconds FrameCaptureIntervalUnit = "MILLISECONDS"
                                                                                                                                                                                                                                                                                                                                                                                                                        	FrameCaptureIntervalUnitSeconds      FrameCaptureIntervalUnit = "SECONDS"
                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for FrameCaptureIntervalUnit

                                                                                                                                                                                                                                                                                                                                                                                                                          func (FrameCaptureIntervalUnit) Values

                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for FrameCaptureIntervalUnit. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                            type FrameCaptureOutputSettings

                                                                                                                                                                                                                                                                                                                                                                                                                            type FrameCaptureOutputSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	// Required if the output group contains more than one output. This modifier forms
                                                                                                                                                                                                                                                                                                                                                                                                                            	// part of the output file name.
                                                                                                                                                                                                                                                                                                                                                                                                                            	NameModifier *string
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              Frame Capture Output Settings

                                                                                                                                                                                                                                                                                                                                                                                                                              type FrameCaptureSettings

                                                                                                                                                                                                                                                                                                                                                                                                                              type FrameCaptureSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	// The frequency at which to capture frames for inclusion in the output. May be
                                                                                                                                                                                                                                                                                                                                                                                                                              	// specified in either seconds or milliseconds, as specified by
                                                                                                                                                                                                                                                                                                                                                                                                                              	// captureIntervalUnits.
                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                              	CaptureInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                              	// Unit for the frame capture interval.
                                                                                                                                                                                                                                                                                                                                                                                                                              	CaptureIntervalUnits FrameCaptureIntervalUnit
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                Frame Capture Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                type GatewayTimeoutException

                                                                                                                                                                                                                                                                                                                                                                                                                                type GatewayTimeoutException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  Placeholder documentation for GatewayTimeoutException

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GatewayTimeoutException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (e *GatewayTimeoutException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GatewayTimeoutException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (e *GatewayTimeoutException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GatewayTimeoutException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (e *GatewayTimeoutException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GatewayTimeoutException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (e *GatewayTimeoutException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                  type GlobalConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                  type GlobalConfiguration struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Value to set the initial audio gain for the Live Event.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	InitialAudioGain int32
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Indicates the action to take when the current input completes (e.g.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// end-of-file). When switchAndLoopInputs is configured the encoder will restart at
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// the beginning of the first input. When "none" is configured the encoder will
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// transcode either black, a solid color, or a user specified slate images per the
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// "Input Loss Behavior" configuration until the next input switch occurs (which is
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// controlled through the Channel Schedule API).
                                                                                                                                                                                                                                                                                                                                                                                                                                  	InputEndAction GlobalConfigurationInputEndAction
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Settings for system actions when input is lost.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	InputLossBehavior *InputLossBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Indicates how MediaLive pipelines are synchronized. PIPELINE_LOCKING - MediaLive
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// will attempt to synchronize the output of each pipeline to the other.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// EPOCH_LOCKING - MediaLive will attempt to synchronize the output of each
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// pipeline to the Unix epoch.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	OutputLockingMode GlobalConfigurationOutputLockingMode
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether the rate of frames emitted by the Live encoder should be paced
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// by its system clock (which optionally may be locked to another source via NTP)
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// or should be locked to the clock of the source that is providing the input
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	OutputTimingSource GlobalConfigurationOutputTimingSource
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Adjusts video input buffer for streams with very low video framerates. This is
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// commonly set to enabled for music channels with less than one video frame per
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// second.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SupportLowFramerateInputs GlobalConfigurationLowFramerateInputs
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                    Global Configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                    type GlobalConfigurationInputEndAction

                                                                                                                                                                                                                                                                                                                                                                                                                                    type GlobalConfigurationInputEndAction string
                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                    	GlobalConfigurationInputEndActionNone                GlobalConfigurationInputEndAction = "NONE"
                                                                                                                                                                                                                                                                                                                                                                                                                                    	GlobalConfigurationInputEndActionSwitchAndLoopInputs GlobalConfigurationInputEndAction = "SWITCH_AND_LOOP_INPUTS"
                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for GlobalConfigurationInputEndAction

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (GlobalConfigurationInputEndAction) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for GlobalConfigurationInputEndAction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type GlobalConfigurationLowFramerateInputs

                                                                                                                                                                                                                                                                                                                                                                                                                                        type GlobalConfigurationLowFramerateInputs string
                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                        	GlobalConfigurationLowFramerateInputsDisabled GlobalConfigurationLowFramerateInputs = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                        	GlobalConfigurationLowFramerateInputsEnabled  GlobalConfigurationLowFramerateInputs = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for GlobalConfigurationLowFramerateInputs

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (GlobalConfigurationLowFramerateInputs) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for GlobalConfigurationLowFramerateInputs. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type GlobalConfigurationOutputLockingMode

                                                                                                                                                                                                                                                                                                                                                                                                                                            type GlobalConfigurationOutputLockingMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                            	GlobalConfigurationOutputLockingModeEpochLocking    GlobalConfigurationOutputLockingMode = "EPOCH_LOCKING"
                                                                                                                                                                                                                                                                                                                                                                                                                                            	GlobalConfigurationOutputLockingModePipelineLocking GlobalConfigurationOutputLockingMode = "PIPELINE_LOCKING"
                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for GlobalConfigurationOutputLockingMode

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (GlobalConfigurationOutputLockingMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for GlobalConfigurationOutputLockingMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type GlobalConfigurationOutputTimingSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                type GlobalConfigurationOutputTimingSource string
                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                	GlobalConfigurationOutputTimingSourceInputClock  GlobalConfigurationOutputTimingSource = "INPUT_CLOCK"
                                                                                                                                                                                                                                                                                                                                                                                                                                                	GlobalConfigurationOutputTimingSourceSystemClock GlobalConfigurationOutputTimingSource = "SYSTEM_CLOCK"
                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for GlobalConfigurationOutputTimingSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (GlobalConfigurationOutputTimingSource) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for GlobalConfigurationOutputTimingSource. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264AdaptiveQuantization

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264AdaptiveQuantization string
                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationHigh   H264AdaptiveQuantization = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationHigher H264AdaptiveQuantization = "HIGHER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationLow    H264AdaptiveQuantization = "LOW"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationMax    H264AdaptiveQuantization = "MAX"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationMedium H264AdaptiveQuantization = "MEDIUM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264AdaptiveQuantizationOff    H264AdaptiveQuantization = "OFF"
                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H264AdaptiveQuantization

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264AdaptiveQuantization) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H264AdaptiveQuantization. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264ColorMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264ColorMetadata string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264ColorMetadataIgnore H264ColorMetadata = "IGNORE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264ColorMetadataInsert H264ColorMetadata = "INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for H264ColorMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (H264ColorMetadata) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for H264ColorMetadata. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264ColorSpaceSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264ColorSpaceSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Passthrough applies no color space conversion to the output
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ColorSpacePassthroughSettings *ColorSpacePassthroughSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Rec601 Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Rec601Settings *Rec601Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Rec709 Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Rec709Settings *Rec709Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              H264 Color Space Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H264EntropyEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H264EntropyEncoding string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H264EntropyEncodingCabac H264EntropyEncoding = "CABAC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H264EntropyEncodingCavlc H264EntropyEncoding = "CAVLC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for H264EntropyEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H264EntropyEncoding) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for H264EntropyEncoding. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H264FilterSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H264FilterSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Temporal Filter Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemporalFilterSettings *TemporalFilterSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    H264 Filter Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264FlickerAq string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264FlickerAqDisabled H264FlickerAq = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264FlickerAqEnabled  H264FlickerAq = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H264FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264FlickerAq) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264FlickerAq) Values() []H264FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H264FlickerAq. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264ForceFieldPictures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264ForceFieldPictures string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264ForceFieldPicturesDisabled H264ForceFieldPictures = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264ForceFieldPicturesEnabled  H264ForceFieldPictures = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for H264ForceFieldPictures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (H264ForceFieldPictures) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for H264ForceFieldPictures. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264FramerateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264FramerateControl string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264FramerateControlInitializeFromSource H264FramerateControl = "INITIALIZE_FROM_SOURCE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264FramerateControlSpecified            H264FramerateControl = "SPECIFIED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for H264FramerateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (H264FramerateControl) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for H264FramerateControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264GopBReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264GopBReference string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264GopBReferenceDisabled H264GopBReference = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264GopBReferenceEnabled  H264GopBReference = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for H264GopBReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H264GopBReference) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for H264GopBReference. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264GopSizeUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264GopSizeUnits string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264GopSizeUnitsFrames  H264GopSizeUnits = "FRAMES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264GopSizeUnitsSeconds H264GopSizeUnits = "SECONDS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H264GopSizeUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264GopSizeUnits) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H264GopSizeUnits. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264Level string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level1    H264Level = "H264_LEVEL_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level11   H264Level = "H264_LEVEL_1_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level12   H264Level = "H264_LEVEL_1_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level13   H264Level = "H264_LEVEL_1_3"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level2    H264Level = "H264_LEVEL_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level21   H264Level = "H264_LEVEL_2_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level22   H264Level = "H264_LEVEL_2_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level3    H264Level = "H264_LEVEL_3"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level31   H264Level = "H264_LEVEL_3_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level32   H264Level = "H264_LEVEL_3_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level4    H264Level = "H264_LEVEL_4"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level41   H264Level = "H264_LEVEL_4_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level42   H264Level = "H264_LEVEL_4_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level5    H264Level = "H264_LEVEL_5"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level51   H264Level = "H264_LEVEL_5_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264Level52   H264Level = "H264_LEVEL_5_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264LevelH264LevelAuto H264Level = "H264_LEVEL_AUTO"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for H264Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (H264Level) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (H264Level) Values() []H264Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for H264Level. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264LookAheadRateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264LookAheadRateControl string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264LookAheadRateControlHigh   H264LookAheadRateControl = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264LookAheadRateControlLow    H264LookAheadRateControl = "LOW"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264LookAheadRateControlMedium H264LookAheadRateControl = "MEDIUM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for H264LookAheadRateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (H264LookAheadRateControl) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for H264LookAheadRateControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264ParControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264ParControl string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264ParControlInitializeFromSource H264ParControl = "INITIALIZE_FROM_SOURCE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264ParControlSpecified            H264ParControl = "SPECIFIED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for H264ParControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H264ParControl) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H264ParControl) Values() []H264ParControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for H264ParControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264Profile string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileBaseline     H264Profile = "BASELINE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileHigh         H264Profile = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileHigh10bit    H264Profile = "HIGH_10BIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileHigh422      H264Profile = "HIGH_422"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileHigh42210bit H264Profile = "HIGH_422_10BIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264ProfileMain         H264Profile = "MAIN"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H264Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264Profile) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264Profile) Values() []H264Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H264Profile. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264QualityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264QualityLevel string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264QualityLevelEnhancedQuality H264QualityLevel = "ENHANCED_QUALITY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	H264QualityLevelStandardQuality H264QualityLevel = "STANDARD_QUALITY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for H264QualityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (H264QualityLevel) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for H264QualityLevel. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264RateControlMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H264RateControlMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264RateControlModeCbr       H264RateControlMode = "CBR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264RateControlModeMultiplex H264RateControlMode = "MULTIPLEX"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264RateControlModeQvbr      H264RateControlMode = "QVBR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	H264RateControlModeVbr       H264RateControlMode = "VBR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for H264RateControlMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (H264RateControlMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for H264RateControlMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H264ScanType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264ScanTypeInterlaced  H264ScanType = "INTERLACED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H264ScanTypeProgressive H264ScanType = "PROGRESSIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for H264ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H264ScanType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H264ScanType) Values() []H264ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for H264ScanType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264SceneChangeDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H264SceneChangeDetect string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264SceneChangeDetectDisabled H264SceneChangeDetect = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H264SceneChangeDetectEnabled  H264SceneChangeDetect = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H264SceneChangeDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H264SceneChangeDetect) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H264SceneChangeDetect. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type H264Settings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Adaptive quantization. Allows intra-frame quantizers to vary to improve visual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// quality.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AdaptiveQuantization H264AdaptiveQuantization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates that AFD values will be written into the output stream. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// afdSignaling is "auto", the system will try to preserve the input AFD value (in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// cases where multiple AFD values are valid). If set to "fixed", the AFD value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// will be the value configured in the fixedAfd parameter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AfdSignaling AfdSignaling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Average bitrate in bits/second. Required when the rate control mode is VBR or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// CBR. Not used for QVBR. In an MS Smooth output group, each output must have a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// unique value when its bitrate is rounded down to the nearest multiple of 1000.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Bitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Percentage of the buffer that should initially be filled (HRD buffer model).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BufFillPct int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Size of buffer (HRD buffer model) in bits.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BufSize int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Includes colorspace metadata in the output.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ColorMetadata H264ColorMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Color Space settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ColorSpaceSettings *H264ColorSpaceSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Entropy encoding mode. Use cabac (must be in Main or High profile) or cavlc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	EntropyEncoding H264EntropyEncoding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Optional filters that you can apply to an encode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FilterSettings *H264FilterSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Four bit AFD value to write on all frames of video in the output stream. Only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// valid when afdSignaling is set to 'Fixed'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FixedAfd FixedAfd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If set to enabled, adjust quantization within each frame to reduce flicker or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// 'pop' on I-frames.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FlickerAq H264FlickerAq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This setting applies only when scan type is "interlaced." It controls whether
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// coding is performed on a field basis or on a frame basis. (When the video is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// progressive, the coding is always performed on a frame basis.) enabled: Force
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// MediaLive to code on a field basis, so that odd and even sets of fields are
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// coded separately. disabled: Code the two sets of fields separately (on a field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// basis) or together (on a frame basis using PAFF), depending on what is most
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// appropriate for the content.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ForceFieldPictures H264ForceFieldPictures
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This field indicates how the output video frame rate is specified. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// "specified" is selected then the output video frame rate is determined by
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// framerateNumerator and framerateDenominator, else if "initializeFromSource" is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// selected then the output video frame rate will be set equal to the input video
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// frame rate of the first input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FramerateControl H264FramerateControl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Framerate denominator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FramerateDenominator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FramerateNumerator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Documentation update needed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GopBReference H264GopBReference
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Frequency of closed GOPs. In streaming applications, it is recommended that this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// as possible. Setting this value to 0 will break output segmenting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GopClosedCadence int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Number of B-frames between reference frames.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GopNumBFrames int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GOP size (keyframe interval) in units of either frames or seconds per
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// gopSizeUnits. If gopSizeUnits is frames, gopSize must be an integer and must be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// greater than or equal to 1. If gopSizeUnits is seconds, gopSize must be greater
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// than 0, but need not be an integer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GopSize float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates if the gopSize is specified in frames or seconds. If seconds the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// system will convert the gopSize into a frame count at run time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GopSizeUnits H264GopSizeUnits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// H.264 Level.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Level H264Level
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Amount of lookahead. A value of low can decrease latency and memory usage, while
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// high can produce better quality for certain content.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LookAheadRateControl H264LookAheadRateControl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// For QVBR: See the tooltip for Quality level For VBR: Set the maximum bitrate in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// order to accommodate expected spikes in the complexity of the video.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MaxBitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// multiplex rate control is used. Enforces separation between repeated (cadence)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// I-frames and I-frames inserted by Scene Change Detection. If a scene change
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// and/or stretched to the scene change I-frame. GOP stretch requires enabling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// lookahead as well as setting I-interval. The normal cadence resumes for the next
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MinIInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Number of reference frames to use. The encoder may use more than requested if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// using B-frames and/or interlaced encoding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NumRefFrames int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This field indicates how the output pixel aspect ratio is specified. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// "specified" is selected then the output video pixel aspect ratio is determined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// by parNumerator and parDenominator, else if "initializeFromSource" is selected
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// then the output pixsel aspect ratio will be set equal to the input video pixel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// aspect ratio of the first input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ParControl H264ParControl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Pixel Aspect Ratio denominator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ParDenominator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Pixel Aspect Ratio numerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ParNumerator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// H.264 Profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Profile H264Profile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Leave as STANDARD_QUALITY or choose a different value (which might result in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// additional costs to run the channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * ENHANCED_QUALITY: Produces a slightly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// better video quality without an increase in the bitrate. Has an effect only when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the Rate control mode is QVBR or CBR. If this channel is in a MediaLive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// multiplex, the value must be ENHANCED_QUALITY.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * STANDARD_QUALITY: Valid for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// any Rate control mode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	QualityLevel H264QualityLevel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Controls the target quality for the video encode. Applies only when the rate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// control mode is QVBR. Set values for the QVBR quality level field and Max
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// bitrate field that suit your most important viewing devices. Recommended values
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// are:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * Primary screen: Quality level: 8 to 10. Max bitrate: 4M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * PC or tablet:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Quality level: 7. Max bitrate: 1.5M to 3M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * Smartphone: Quality level: 6. Max
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// bitrate: 1M to 1.5M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	QvbrQualityLevel int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Rate control mode. QVBR: Quality will match the specified quality level except
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// when it is constrained by the maximum bitrate. Recommended if you or your
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// viewers pay for bandwidth. VBR: Quality and bitrate vary, depending on the video
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// complexity. Recommended instead of QVBR if you want to maintain a specific
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// average bitrate over the duration of the channel. CBR: Quality varies, depending
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// on the video complexity. Recommended only if you distribute your assets to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// devices that cannot handle variable bitrates. Multiplex: This rate control mode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// is only supported (and is required) when the video is being delivered to a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// MediaLive Multiplex in which case the rate control configuration is controlled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// by the properties within the Multiplex Program.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RateControlMode H264RateControlMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Sets the scan type of the output to progressive or top-field-first interlaced.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ScanType H264ScanType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Scene change detection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * On: inserts I-frames when scene change is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// detected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * Off: does not force an I-frame when scene change is detected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SceneChangeDetect H264SceneChangeDetect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Number of slices per picture. Must be less than or equal to the number of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// macroblock rows for progressive pictures, and less than or equal to half the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// number of macroblock rows for interlaced pictures. This field is optional; when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// no value is specified the encoder will choose the number of slices based on
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// encode resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Slices int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Softness. Selects quantizer matrix, larger values reduce high-frequency content
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// in the encoded image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Softness int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If set to enabled, adjust quantization within each frame based on spatial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// variation of content complexity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SpatialAq H264SpatialAq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If set to fixed, use gopNumBFrames B-frames per sub-GOP. If set to dynamic,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// optimize the number of B-frames used for each sub-GOP to improve visual quality.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SubgopLength H264SubGopLength
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Produces a bitstream compliant with SMPTE RP-2027.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Syntax H264Syntax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If set to enabled, adjust quantization within each frame based on temporal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// variation of content complexity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TemporalAq H264TemporalAq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Determines how timecodes should be inserted into the video elementary stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// 'disabled': Do not include timecodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// * 'picTimingSei': Pass through picture
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// timing SEI messages from the source specified in Timecode Config
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TimecodeInsertion H264TimecodeInsertionBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          H264 Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H264SpatialAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H264SpatialAq string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H264SpatialAqDisabled H264SpatialAq = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H264SpatialAqEnabled  H264SpatialAq = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for H264SpatialAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (H264SpatialAq) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (H264SpatialAq) Values() []H264SpatialAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for H264SpatialAq. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H264SubGopLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H264SubGopLength string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H264SubGopLengthDynamic H264SubGopLength = "DYNAMIC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H264SubGopLengthFixed   H264SubGopLength = "FIXED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for H264SubGopLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H264SubGopLength) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for H264SubGopLength. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H264Syntax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H264Syntax string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H264SyntaxDefault H264Syntax = "DEFAULT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H264SyntaxRp2027  H264Syntax = "RP2027"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for H264Syntax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (H264Syntax) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (H264Syntax) Values() []H264Syntax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for H264Syntax. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H264TemporalAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H264TemporalAq string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H264TemporalAqDisabled H264TemporalAq = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H264TemporalAqEnabled  H264TemporalAq = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for H264TemporalAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H264TemporalAq) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H264TemporalAq) Values() []H264TemporalAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for H264TemporalAq. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H264TimecodeInsertionBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H264TimecodeInsertionBehavior string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H264TimecodeInsertionBehaviorDisabled     H264TimecodeInsertionBehavior = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H264TimecodeInsertionBehaviorPicTimingSei H264TimecodeInsertionBehavior = "PIC_TIMING_SEI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for H264TimecodeInsertionBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (H264TimecodeInsertionBehavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for H264TimecodeInsertionBehavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265AdaptiveQuantization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265AdaptiveQuantization string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationHigh   H265AdaptiveQuantization = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationHigher H265AdaptiveQuantization = "HIGHER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationLow    H265AdaptiveQuantization = "LOW"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationMax    H265AdaptiveQuantization = "MAX"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationMedium H265AdaptiveQuantization = "MEDIUM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265AdaptiveQuantizationOff    H265AdaptiveQuantization = "OFF"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for H265AdaptiveQuantization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H265AdaptiveQuantization) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for H265AdaptiveQuantization. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265AlternativeTransferFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265AlternativeTransferFunction string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265AlternativeTransferFunctionInsert H265AlternativeTransferFunction = "INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265AlternativeTransferFunctionOmit   H265AlternativeTransferFunction = "OMIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for H265AlternativeTransferFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (H265AlternativeTransferFunction) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for H265AlternativeTransferFunction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265ColorMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265ColorMetadata string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265ColorMetadataIgnore H265ColorMetadata = "IGNORE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265ColorMetadataInsert H265ColorMetadata = "INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for H265ColorMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H265ColorMetadata) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for H265ColorMetadata. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265ColorSpaceSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265ColorSpaceSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Passthrough applies no color space conversion to the output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ColorSpacePassthroughSettings *ColorSpacePassthroughSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Hdr10 Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Hdr10Settings *Hdr10Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Rec601 Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Rec601Settings *Rec601Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Rec709 Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Rec709Settings *Rec709Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            H265 Color Space Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H265FilterSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type H265FilterSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Temporal Filter Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TemporalFilterSettings *TemporalFilterSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              H265 Filter Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265FlickerAq string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265FlickerAqDisabled H265FlickerAq = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265FlickerAqEnabled  H265FlickerAq = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for H265FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H265FlickerAq) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H265FlickerAq) Values() []H265FlickerAq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for H265FlickerAq. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265GopSizeUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265GopSizeUnits string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265GopSizeUnitsFrames  H265GopSizeUnits = "FRAMES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265GopSizeUnitsSeconds H265GopSizeUnits = "SECONDS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for H265GopSizeUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (H265GopSizeUnits) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for H265GopSizeUnits. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265Level string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level1    H265Level = "H265_LEVEL_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level2    H265Level = "H265_LEVEL_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level21   H265Level = "H265_LEVEL_2_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level3    H265Level = "H265_LEVEL_3"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level31   H265Level = "H265_LEVEL_3_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level4    H265Level = "H265_LEVEL_4"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level41   H265Level = "H265_LEVEL_4_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level5    H265Level = "H265_LEVEL_5"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level51   H265Level = "H265_LEVEL_5_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level52   H265Level = "H265_LEVEL_5_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level6    H265Level = "H265_LEVEL_6"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level61   H265Level = "H265_LEVEL_6_1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265Level62   H265Level = "H265_LEVEL_6_2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265LevelH265LevelAuto H265Level = "H265_LEVEL_AUTO"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for H265Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H265Level) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H265Level) Values() []H265Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for H265Level. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265LookAheadRateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265LookAheadRateControl string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H265LookAheadRateControlHigh   H265LookAheadRateControl = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H265LookAheadRateControlLow    H265LookAheadRateControl = "LOW"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H265LookAheadRateControlMedium H265LookAheadRateControl = "MEDIUM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for H265LookAheadRateControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (H265LookAheadRateControl) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for H265LookAheadRateControl. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265Profile string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265ProfileMain      H265Profile = "MAIN"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	H265ProfileMain10bit H265Profile = "MAIN_10BIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for H265Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H265Profile) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (H265Profile) Values() []H265Profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for H265Profile. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265RateControlMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type H265RateControlMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265RateControlModeCbr       H265RateControlMode = "CBR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265RateControlModeMultiplex H265RateControlMode = "MULTIPLEX"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	H265RateControlModeQvbr      H265RateControlMode = "QVBR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for H265RateControlMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (H265RateControlMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for H265RateControlMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type H265ScanType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265ScanTypeInterlaced  H265ScanType = "INTERLACED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	H265ScanTypeProgressive H265ScanType = "PROGRESSIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for H265ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H265ScanType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (H265ScanType) Values() []H265ScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for H265ScanType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265SceneChangeDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type H265SceneChangeDetect string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H265SceneChangeDetectDisabled H265SceneChangeDetect = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	H265SceneChangeDetectEnabled  H265SceneChangeDetect = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for H265SceneChangeDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (H265SceneChangeDetect) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for H265SceneChangeDetect. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type H265Settings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Framerate denominator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FramerateDenominator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FramerateNumerator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Adaptive quantization. Allows intra-frame quantizers to vary to improve visual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// quality.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	AdaptiveQuantization H265AdaptiveQuantization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Indicates that AFD values will be written into the output stream. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// afdSignaling is "auto", the system will try to preserve the input AFD value (in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// cases where multiple AFD values are valid). If set to "fixed", the AFD value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// will be the value configured in the fixedAfd parameter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	AfdSignaling AfdSignaling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Whether or not EML should insert an Alternative Transfer Function SEI message to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// support backwards compatibility with non-HDR decoders and displays.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	AlternativeTransferFunction H265AlternativeTransferFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Average bitrate in bits/second. Required when the rate control mode is VBR or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// CBR. Not used for QVBR. In an MS Smooth output group, each output must have a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// unique value when its bitrate is rounded down to the nearest multiple of 1000.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Bitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Size of buffer (HRD buffer model) in bits.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BufSize int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Includes colorspace metadata in the output.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorMetadata H265ColorMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Color Space settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorSpaceSettings *H265ColorSpaceSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Optional filters that you can apply to an encode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FilterSettings *H265FilterSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Four bit AFD value to write on all frames of video in the output stream. Only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// valid when afdSignaling is set to 'Fixed'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FixedAfd FixedAfd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// If set to enabled, adjust quantization within each frame to reduce flicker or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 'pop' on I-frames.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FlickerAq H265FlickerAq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Frequency of closed GOPs. In streaming applications, it is recommended that this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// as possible. Setting this value to 0 will break output segmenting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GopClosedCadence int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// GOP size (keyframe interval) in units of either frames or seconds per
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// gopSizeUnits. If gopSizeUnits is frames, gopSize must be an integer and must be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// greater than or equal to 1. If gopSizeUnits is seconds, gopSize must be greater
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// than 0, but need not be an integer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GopSize float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Indicates if the gopSize is specified in frames or seconds. If seconds the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// system will convert the gopSize into a frame count at run time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GopSizeUnits H265GopSizeUnits
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// H.265 Level.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Level H265Level
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Amount of lookahead. A value of low can decrease latency and memory usage, while
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// high can produce better quality for certain content.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	LookAheadRateControl H265LookAheadRateControl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// For QVBR: See the tooltip for Quality level
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MaxBitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// multiplex rate control is used. Enforces separation between repeated (cadence)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// I-frames and I-frames inserted by Scene Change Detection. If a scene change
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// and/or stretched to the scene change I-frame. GOP stretch requires enabling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// lookahead as well as setting I-interval. The normal cadence resumes for the next
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MinIInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Pixel Aspect Ratio denominator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ParDenominator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Pixel Aspect Ratio numerator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ParNumerator int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// H.265 Profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Profile H265Profile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Controls the target quality for the video encode. Applies only when the rate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// control mode is QVBR. Set values for the QVBR quality level field and Max
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// bitrate field that suit your most important viewing devices. Recommended values
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// are:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * Primary screen: Quality level: 8 to 10. Max bitrate: 4M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * PC or tablet:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Quality level: 7. Max bitrate: 1.5M to 3M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * Smartphone: Quality level: 6. Max
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// bitrate: 1M to 1.5M
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	QvbrQualityLevel int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Rate control mode. QVBR: Quality will match the specified quality level except
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// when it is constrained by the maximum bitrate. Recommended if you or your
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// viewers pay for bandwidth. CBR: Quality varies, depending on the video
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// complexity. Recommended only if you distribute your assets to devices that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// cannot handle variable bitrates. Multiplex: This rate control mode is only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// supported (and is required) when the video is being delivered to a MediaLive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Multiplex in which case the rate control configuration is controlled by the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// properties within the Multiplex Program.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RateControlMode H265RateControlMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Sets the scan type of the output to progressive or top-field-first interlaced.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ScanType H265ScanType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Scene change detection.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SceneChangeDetect H265SceneChangeDetect
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Number of slices per picture. Must be less than or equal to the number of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// macroblock rows for progressive pictures, and less than or equal to half the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// number of macroblock rows for interlaced pictures. This field is optional; when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// no value is specified the encoder will choose the number of slices based on
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// encode resolution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Slices int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// H.265 Tier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Tier H265Tier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Determines how timecodes should be inserted into the video elementary stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 'disabled': Do not include timecodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// * 'picTimingSei': Pass through picture
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// timing SEI messages from the source specified in Timecode Config
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TimecodeInsertion H265TimecodeInsertionBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                H265 Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H265Tier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type H265Tier string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H265TierHigh H265Tier = "HIGH"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H265TierMain H265Tier = "MAIN"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for H265Tier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H265Tier) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (H265Tier) Values() []H265Tier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for H265Tier. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H265TimecodeInsertionBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type H265TimecodeInsertionBehavior string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H265TimecodeInsertionBehaviorDisabled     H265TimecodeInsertionBehavior = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	H265TimecodeInsertionBehaviorPicTimingSei H265TimecodeInsertionBehavior = "PIC_TIMING_SEI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for H265TimecodeInsertionBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (H265TimecodeInsertionBehavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for H265TimecodeInsertionBehavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Hdr10Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Hdr10Settings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Maximum Content Light Level An integer metadata value defining the maximum light
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// level, in nits, of any single pixel within an encoded HDR video stream or file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MaxCll int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Maximum Frame Average Light Level An integer metadata value defining the maximum
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// average light level, in nits, for any single frame within an encoded HDR video
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// stream or file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MaxFall int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Hdr10 Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsAdMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsAdMarkers string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsAdMarkersAdobe           HlsAdMarkers = "ADOBE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsAdMarkersElemental       HlsAdMarkers = "ELEMENTAL"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsAdMarkersElementalScte35 HlsAdMarkers = "ELEMENTAL_SCTE35"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for HlsAdMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsAdMarkers) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsAdMarkers) Values() []HlsAdMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for HlsAdMarkers. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsAkamaiHttpTransferMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsAkamaiHttpTransferMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsAkamaiHttpTransferModeChunked    HlsAkamaiHttpTransferMode = "CHUNKED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsAkamaiHttpTransferModeNonChunked HlsAkamaiHttpTransferMode = "NON_CHUNKED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for HlsAkamaiHttpTransferMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (HlsAkamaiHttpTransferMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for HlsAkamaiHttpTransferMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsAkamaiSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsAkamaiSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of seconds to wait before retrying connection to the CDN if the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// connection is lost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ConnectionRetryInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Size in seconds of file cache for streaming outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FilecacheDuration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specify whether or not to use chunked transfer encoding to Akamai. User should
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contact Akamai to enable this feature.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HttpTransferMode HlsAkamaiHttpTransferMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of retry attempts that will be made before the Live Event is put into an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// error state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NumRetries int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// If a streaming output fails, number of seconds to wait until a restart is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// initiated. A value of 0 means never restart.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RestartDelay int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Salt for authenticated Akamai.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Salt *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Token parameter for authenticated akamai. If not specified, gda is used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Token *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hls Akamai Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsBasicPutSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsBasicPutSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Number of seconds to wait before retrying connection to the CDN if the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// connection is lost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ConnectionRetryInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Size in seconds of file cache for streaming outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FilecacheDuration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Number of retry attempts that will be made before the Live Event is put into an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// error state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NumRetries int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// If a streaming output fails, number of seconds to wait until a restart is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// initiated. A value of 0 means never restart.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	RestartDelay int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hls Basic Put Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsCaptionLanguageSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsCaptionLanguageSetting string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsCaptionLanguageSettingInsert HlsCaptionLanguageSetting = "INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsCaptionLanguageSettingNone   HlsCaptionLanguageSetting = "NONE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsCaptionLanguageSettingOmit   HlsCaptionLanguageSetting = "OMIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for HlsCaptionLanguageSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HlsCaptionLanguageSetting) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for HlsCaptionLanguageSetting. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsCdnSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsCdnSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Hls Akamai Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsAkamaiSettings *HlsAkamaiSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Hls Basic Put Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsBasicPutSettings *HlsBasicPutSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Hls Media Store Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsMediaStoreSettings *HlsMediaStoreSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Hls Webdav Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsWebdavSettings *HlsWebdavSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hls Cdn Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsClientCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsClientCache string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsClientCacheDisabled HlsClientCache = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsClientCacheEnabled  HlsClientCache = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for HlsClientCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (HlsClientCache) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (HlsClientCache) Values() []HlsClientCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for HlsClientCache. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsCodecSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsCodecSpecification string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsCodecSpecificationRfc4281 HlsCodecSpecification = "RFC_4281"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsCodecSpecificationRfc6381 HlsCodecSpecification = "RFC_6381"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for HlsCodecSpecification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (HlsCodecSpecification) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for HlsCodecSpecification. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsDirectoryStructure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsDirectoryStructure string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsDirectoryStructureSingleDirectory       HlsDirectoryStructure = "SINGLE_DIRECTORY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsDirectoryStructureSubdirectoryPerStream HlsDirectoryStructure = "SUBDIRECTORY_PER_STREAM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for HlsDirectoryStructure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (HlsDirectoryStructure) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for HlsDirectoryStructure. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsDiscontinuityTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsDiscontinuityTags string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsDiscontinuityTagsInsert      HlsDiscontinuityTags = "INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsDiscontinuityTagsNeverInsert HlsDiscontinuityTags = "NEVER_INSERT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for HlsDiscontinuityTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (HlsDiscontinuityTags) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for HlsDiscontinuityTags. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsEncryptionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsEncryptionType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsEncryptionTypeAes128    HlsEncryptionType = "AES128"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsEncryptionTypeSampleAes HlsEncryptionType = "SAMPLE_AES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for HlsEncryptionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (HlsEncryptionType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for HlsEncryptionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsGroupSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsGroupSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A directory or HTTP destination for the HLS segments, manifest files, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// encryption keys (if enabled).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Destination *OutputLocationRef
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Choose one or more ad marker types to pass SCTE35 signals through to this group
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// of Apple HLS outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AdMarkers []HlsAdMarkers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A partial URI prefix that will be prepended to each output in the media .m3u8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// file. Can be used if base manifest is delivered from a different URL than the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// main .m3u8 file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BaseUrlContent *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Optional. One value per output group. This field is required only if you are
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// completing Base URL content A, and the downstream system has notified you that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the media files for pipeline 1 of all outputs are in a location different from
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the media files for pipeline 0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BaseUrlContent1 *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A partial URI prefix that will be prepended to each output in the media .m3u8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// file. Can be used if base manifest is delivered from a different URL than the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// main .m3u8 file.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BaseUrlManifest *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Optional. One value per output group. Complete this field only if you are
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// completing Base URL manifest A, and the downstream system has notified you that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the child manifest files for pipeline 1 of all outputs are in a location
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// different from the child manifest files for pipeline 0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BaseUrlManifest1 *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Mapping of up to 4 caption channels to caption languages. Is only meaningful if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// captionLanguageSetting is set to "insert".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CaptionLanguageMappings []CaptionLanguageMapping
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Applies only to 608 Embedded output captions. insert: Include CLOSED-CAPTIONS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// lines in the manifest. Specify at least one language in the CC1 Language Code
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// field. One CLOSED-CAPTION line is added for each Language Code you specify. Make
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// sure to specify the languages in the order in which they appear in the original
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// source (if the source is embedded format) or the order of the caption selectors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// (if the source is other than embedded). Otherwise, languages in the manifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// will not match up properly with the output captions. none: Include
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CLOSED-CAPTIONS=NONE line in the manifest. omit: Omit any CLOSED-CAPTIONS line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// from the manifest.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CaptionLanguageSetting HlsCaptionLanguageSetting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// When set to "disabled", sets the #EXT-X-ALLOW-CACHE:no tag in the manifest,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// which prevents clients from saving media segments for later replay.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ClientCache HlsClientCache
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Specification to use (RFC-6381 or the default RFC-4281) during m3u8 playlist
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// generation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CodecSpecification HlsCodecSpecification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// For use with encryptionType. This is a 128-bit, 16-byte hex value represented by
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// a 32-character text string. If ivSource is set to "explicit" then this parameter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// is required and is used as the IV for encryption.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ConstantIv *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Place segments in subdirectories.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DirectoryStructure HlsDirectoryStructure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Specifies whether to insert EXT-X-DISCONTINUITY tags in the HLS child manifests
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// for this output group. Typically, choose Insert because these tags are required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// in the manifest (according to the HLS specification) and serve an important
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// purpose. Choose Never Insert only if the downstream system is doing real-time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// failover (without using the MediaLive automatic failover feature) and only if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// that downstream system has advised you to exclude the tags.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DiscontinuityTags HlsDiscontinuityTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Encrypts the segments with the given encryption scheme. Exclude this parameter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// if no encryption is desired.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EncryptionType HlsEncryptionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Parameters that control interactions with the CDN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsCdnSettings *HlsCdnSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// State of HLS ID3 Segment Tagging
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsId3SegmentTagging HlsId3SegmentTaggingState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DISABLED: Do not create an I-frame-only manifest, but do create the master and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// media manifests (according to the Output Selection field). STANDARD: Create an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// I-frame-only manifest for each output that contains video, as well as the other
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// manifests (according to the Output Selection field). The I-frame manifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains a #EXT-X-I-FRAMES-ONLY tag to indicate it is I-frame only, and one or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// more #EXT-X-BYTERANGE entries identifying the I-frame position. For example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// #EXT-X-BYTERANGE:160364@1461888"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IFrameOnlyPlaylists IFrameOnlyPlaylistType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Specifies whether to include the final (incomplete) segment in the media output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// when the pipeline stops producing output because of a channel stop, a channel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// pause or a loss of input to the pipeline. Auto means that MediaLive decides
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// whether to include the final segment, depending on the channel class and the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// types of output groups. Suppress means to never include the incomplete segment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// We recommend you choose Auto and let MediaLive control the behavior.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IncompleteSegmentBehavior HlsIncompleteSegmentBehavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Applies only if Mode field is LIVE. Specifies the maximum number of segments in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the media manifest file. After this maximum, older segments are removed from the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// media manifest. This number must be smaller than the number in the Keep Segments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// field.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IndexNSegments int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Parameter that control output group behavior on input loss.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputLossAction InputLossActionForHlsOut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// For use with encryptionType. The IV (Initialization Vector) is a 128-bit number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// used in conjunction with the key for encrypting blocks. If set to "include", IV
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// is listed in the manifest, otherwise the IV is not in the manifest.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IvInManifest HlsIvInManifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// For use with encryptionType. The IV (Initialization Vector) is a 128-bit number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// used in conjunction with the key for encrypting blocks. If this setting is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// "followsSegmentNumber", it will cause the IV to change every segment (to match
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the segment number). If this is set to "explicit", you must enter a constantIv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// value.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IvSource HlsIvSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Applies only if Mode field is LIVE. Specifies the number of media segments to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// retain in the destination directory. This number should be bigger than
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// indexNSegments (Num segments). We recommend (value = (2 x indexNsegments) + 1).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// If this "keep segments" number is too low, the following might happen: the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// player is still reading a media manifest file that lists this segment, but that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// segment has been removed from the destination directory (as directed by
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// indexNSegments). This situation would result in a 404 HTTP error on the player.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	KeepSegments int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The value specifies how the key is represented in the resource identified by the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// URI. If parameter is absent, an implicit value of "identity" is used. A reverse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DNS string can also be given.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	KeyFormat *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Either a single positive integer version value or a slash delimited list of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// version values (1/2/3).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	KeyFormatVersions *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The key provider settings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	KeyProviderSettings *KeyProviderSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// When set to gzip, compresses HLS playlist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ManifestCompression HlsManifestCompression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Indicates whether the output manifest should use floating point or integer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// values for segment duration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ManifestDurationFormat HlsManifestDurationFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// When set, minimumSegmentLength is enforced by looking ahead and back within the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// specified range for a nearby avail and extending the segment size if needed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MinSegmentLength int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// If "vod", all segments are indexed and kept permanently in the destination and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// manifest. If "live", only the number segments specified in keepSegments and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// indexNSegments are kept; newer segments replace older segments, which may
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// prevent players from rewinding all the way to the beginning of the event. VOD
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// mode uses HLS EXT-X-PLAYLIST-TYPE of EVENT while the channel is running,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// converting it to a "VOD" type manifest on completion of the stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Mode HlsMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// MANIFESTS_AND_SEGMENTS: Generates manifests (master manifest, if applicable, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// media manifests) for this output group. VARIANT_MANIFESTS_AND_SEGMENTS:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Generates media manifests for this output group, but not a master manifest.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SEGMENTS_ONLY: Does not generate any manifests for this output group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	OutputSelection HlsOutputSelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Includes or excludes EXT-X-PROGRAM-DATE-TIME tag in .m3u8 manifest files. The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// value is calculated as follows: either the program date and time are initialized
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// using the input timecode source, or the time is initialized using the input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// timecode source and the date is initialized using the timestampOffset.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ProgramDateTime HlsProgramDateTime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Period of insertion of EXT-X-PROGRAM-DATE-TIME entry, in seconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ProgramDateTimePeriod int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ENABLED: The master manifest (.m3u8 file) for each pipeline includes information
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// about both pipelines: first its own media files, then the media files of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// other pipeline. This feature allows playout device that support stale manifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// detection to switch from one manifest to the other, when the current manifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// seems to be stale. There are still two destinations and two master manifests,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// but both master manifests reference the media files from both pipelines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DISABLED: The master manifest (.m3u8 file) for each pipeline includes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// information about its own pipeline only. For an HLS output group with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// MediaPackage as the destination, the DISABLED behavior is always followed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// MediaPackage regenerates the manifests it serves to players so a redundant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// manifest from MediaLive is irrelevant.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	RedundantManifest HlsRedundantManifest
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Length of MPEG-2 Transport Stream segments to create (in seconds). Note that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// segments will end on the next keyframe after this number of seconds, so actual
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// segment length may be longer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SegmentLength int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// useInputSegmentation has been deprecated. The configured segment size is always
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SegmentationMode HlsSegmentationMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Number of segments to write to a subdirectory before starting a new one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// directoryStructure must be subdirectoryPerStream for this setting to have an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// effect.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SegmentsPerSubdirectory int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Include or exclude RESOLUTION attribute for video in EXT-X-STREAM-INF tag of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// variant manifest.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	StreamInfResolution HlsStreamInfResolution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Indicates ID3 frame that has the timecode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TimedMetadataId3Frame HlsTimedMetadataId3Frame
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Timed Metadata interval in seconds.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TimedMetadataId3Period int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Provides an extra millisecond delta offset to fine tune the timestamps.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TimestampDeltaMilliseconds int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SEGMENTED_FILES: Emit the program as segments - multiple .ts media files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// SINGLE_FILE: Applies only if Mode field is VOD. Emit the program as a single .ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// media file. The media manifest includes #EXT-X-BYTERANGE tags to index segments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// for playback. A typical use for this value is when sending the output to AWS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Elemental MediaConvert, which can accept only a single media file. Playback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// while the channel is running is not guaranteed due to HTTP server caching.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TsFileMode HlsTsFileMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hls Group Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsH265PackagingType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsH265PackagingType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsH265PackagingTypeHev1 HlsH265PackagingType = "HEV1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsH265PackagingTypeHvc1 HlsH265PackagingType = "HVC1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for HlsH265PackagingType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (HlsH265PackagingType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for HlsH265PackagingType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsId3SegmentTaggingScheduleActionSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsId3SegmentTaggingScheduleActionSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// ID3 tag to insert into each segment. Supports special keyword identifiers to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// substitute in segment-related values.\nSupported keyword identifiers:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// https://docs.aws.amazon.com/medialive/latest/ug/variable-data-identifiers.html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tag *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings for the action to insert a user-defined ID3 tag in each HLS segment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsId3SegmentTaggingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsId3SegmentTaggingState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsId3SegmentTaggingStateDisabled HlsId3SegmentTaggingState = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsId3SegmentTaggingStateEnabled  HlsId3SegmentTaggingState = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for HlsId3SegmentTaggingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (HlsId3SegmentTaggingState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for HlsId3SegmentTaggingState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsIncompleteSegmentBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsIncompleteSegmentBehavior string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsIncompleteSegmentBehaviorAuto     HlsIncompleteSegmentBehavior = "AUTO"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsIncompleteSegmentBehaviorSuppress HlsIncompleteSegmentBehavior = "SUPPRESS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for HlsIncompleteSegmentBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (HlsIncompleteSegmentBehavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for HlsIncompleteSegmentBehavior. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsInputSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsInputSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// When specified the HLS stream with the m3u8 BANDWIDTH that most closely matches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// this value will be chosen, otherwise the highest bandwidth stream in the m3u8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// will be chosen. The bitrate is specified in bits per second, as in an HLS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// manifest.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Bandwidth int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// When specified, reading of the HLS input will begin this many buffer segments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// from the end (most recently written segment). When not specified, the HLS input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// will begin with the first segment specified in the m3u8.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BufferSegments int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The number of consecutive times that attempts to read a manifest or segment must
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// fail before the input is considered unavailable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Retries int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The number of seconds between retries when an attempt to read a manifest or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// segment fails.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	RetryInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hls Input Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsIvInManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsIvInManifest string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsIvInManifestExclude HlsIvInManifest = "EXCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsIvInManifestInclude HlsIvInManifest = "INCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for HlsIvInManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (HlsIvInManifest) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (HlsIvInManifest) Values() []HlsIvInManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for HlsIvInManifest. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsIvSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsIvSource string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsIvSourceExplicit             HlsIvSource = "EXPLICIT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsIvSourceFollowsSegmentNumber HlsIvSource = "FOLLOWS_SEGMENT_NUMBER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for HlsIvSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HlsIvSource) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HlsIvSource) Values() []HlsIvSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for HlsIvSource. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsManifestCompression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsManifestCompression string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsManifestCompressionGzip HlsManifestCompression = "GZIP"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsManifestCompressionNone HlsManifestCompression = "NONE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for HlsManifestCompression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsManifestCompression) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for HlsManifestCompression. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsManifestDurationFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsManifestDurationFormat string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsManifestDurationFormatFloatingPoint HlsManifestDurationFormat = "FLOATING_POINT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsManifestDurationFormatInteger       HlsManifestDurationFormat = "INTEGER"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for HlsManifestDurationFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (HlsManifestDurationFormat) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for HlsManifestDurationFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsMediaStoreSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsMediaStoreSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of seconds to wait before retrying connection to the CDN if the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// connection is lost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ConnectionRetryInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Size in seconds of file cache for streaming outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FilecacheDuration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// When set to temporal, output files are stored in non-persistent memory for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// faster reading and writing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MediaStoreStorageClass HlsMediaStoreStorageClass
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of retry attempts that will be made before the Live Event is put into an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// error state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NumRetries int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// If a streaming output fails, number of seconds to wait until a restart is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// initiated. A value of 0 means never restart.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RestartDelay int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hls Media Store Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsMediaStoreStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsMediaStoreStorageClass string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsMediaStoreStorageClassTemporal HlsMediaStoreStorageClass = "TEMPORAL"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for HlsMediaStoreStorageClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (HlsMediaStoreStorageClass) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for HlsMediaStoreStorageClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsModeLive HlsMode = "LIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HlsModeVod  HlsMode = "VOD"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for HlsMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (HlsMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (HlsMode) Values() []HlsMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for HlsMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsOutputSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HlsOutputSelection string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsOutputSelectionManifestsAndSegments        HlsOutputSelection = "MANIFESTS_AND_SEGMENTS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsOutputSelectionSegmentsOnly                HlsOutputSelection = "SEGMENTS_ONLY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HlsOutputSelectionVariantManifestsAndSegments HlsOutputSelection = "VARIANT_MANIFESTS_AND_SEGMENTS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for HlsOutputSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (HlsOutputSelection) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for HlsOutputSelection. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsOutputSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsOutputSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Settings regarding the underlying stream. These settings are different for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// audio-only outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsSettings *HlsSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Only applicable when this output is referencing an H.265 video description.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Specifies whether MP4 segments should be packaged as HEV1 or HVC1.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	H265PackagingType HlsH265PackagingType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// String concatenated to the end of the destination filename. Accepts "Format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Identifiers":#formatIdentifierParameters.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NameModifier *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// String concatenated to end of segment filenames.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SegmentModifier *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Hls Output Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsProgramDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsProgramDateTime string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsProgramDateTimeExclude HlsProgramDateTime = "EXCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HlsProgramDateTimeInclude HlsProgramDateTime = "INCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for HlsProgramDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (HlsProgramDateTime) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for HlsProgramDateTime. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsRedundantManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HlsRedundantManifest string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsRedundantManifestDisabled HlsRedundantManifest = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HlsRedundantManifestEnabled  HlsRedundantManifest = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for HlsRedundantManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HlsRedundantManifest) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for HlsRedundantManifest. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsSegmentationMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsSegmentationMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsSegmentationModeUseInputSegmentation HlsSegmentationMode = "USE_INPUT_SEGMENTATION"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsSegmentationModeUseSegmentDuration   HlsSegmentationMode = "USE_SEGMENT_DURATION"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for HlsSegmentationMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsSegmentationMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for HlsSegmentationMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Audio Only Hls Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	AudioOnlyHlsSettings *AudioOnlyHlsSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Fmp4 Hls Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Fmp4HlsSettings *Fmp4HlsSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Standard Hls Settings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	StandardHlsSettings *StandardHlsSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Hls Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsStreamInfResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HlsStreamInfResolution string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsStreamInfResolutionExclude HlsStreamInfResolution = "EXCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	HlsStreamInfResolutionInclude HlsStreamInfResolution = "INCLUDE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for HlsStreamInfResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (HlsStreamInfResolution) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for HlsStreamInfResolution. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsTimedMetadataId3Frame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HlsTimedMetadataId3Frame string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsTimedMetadataId3FrameNone HlsTimedMetadataId3Frame = "NONE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsTimedMetadataId3FramePriv HlsTimedMetadataId3Frame = "PRIV"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	HlsTimedMetadataId3FrameTdrl HlsTimedMetadataId3Frame = "TDRL"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for HlsTimedMetadataId3Frame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (HlsTimedMetadataId3Frame) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for HlsTimedMetadataId3Frame. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsTimedMetadataScheduleActionSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HlsTimedMetadataScheduleActionSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Base64 string formatted according to the ID3 specification:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// http://id3.org/id3v2.4.0-structure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Id3 *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings for the action to emit HLS metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsTsFileMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HlsTsFileMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsTsFileModeSegmentedFiles HlsTsFileMode = "SEGMENTED_FILES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HlsTsFileModeSingleFile     HlsTsFileMode = "SINGLE_FILE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for HlsTsFileMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsTsFileMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (HlsTsFileMode) Values() []HlsTsFileMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for HlsTsFileMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsWebdavHttpTransferMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HlsWebdavHttpTransferMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsWebdavHttpTransferModeChunked    HlsWebdavHttpTransferMode = "CHUNKED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	HlsWebdavHttpTransferModeNonChunked HlsWebdavHttpTransferMode = "NON_CHUNKED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for HlsWebdavHttpTransferMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (HlsWebdavHttpTransferMode) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for HlsWebdavHttpTransferMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsWebdavSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HlsWebdavSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of seconds to wait before retrying connection to the CDN if the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// connection is lost.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ConnectionRetryInterval int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Size in seconds of file cache for streaming outputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FilecacheDuration int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specify whether or not to use chunked transfer encoding to WebDAV.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HttpTransferMode HlsWebdavHttpTransferMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Number of retry attempts that will be made before the Live Event is put into an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// error state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NumRetries int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// If a streaming output fails, number of seconds to wait until a restart is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// initiated. A value of 0 means never restart.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RestartDelay int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hls Webdav Settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IFrameOnlyPlaylistType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IFrameOnlyPlaylistType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IFrameOnlyPlaylistTypeDisabled IFrameOnlyPlaylistType = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IFrameOnlyPlaylistTypeStandard IFrameOnlyPlaylistType = "STANDARD"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for IFrameOnlyPlaylistType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (IFrameOnlyPlaylistType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for IFrameOnlyPlaylistType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ImmediateModeScheduleActionStartSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ImmediateModeScheduleActionStartSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Settings to configure an action so that it occurs as soon as possible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Input struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Unique ARN of the input (generated, immutable).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of channel IDs that that input is attached to (currently an input can
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// only be attached to one channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AttachedChannels []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of the destinations of the input (PUSH-type).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Destinations []InputDestination
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The generated ID of the input (unique for user account, immutable).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// STANDARD - MediaLive expects two sources to be connected to this input. If the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// channel is also STANDARD, both sources will be ingested. If the channel is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// SINGLE_PIPELINE, only the first source will be ingested; the second source will
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// always be ignored, even if the first source fails. SINGLE_PIPELINE - You can
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// connect only one source to this input. If the ChannelClass is also
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// SINGLE_PIPELINE, this value is valid. If the ChannelClass is STANDARD, this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// value is not valid because the channel requires two sources in the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputClass InputClass
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Settings for the input devices.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputDevices []InputDeviceSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Certain pull input sources can be dynamic, meaning that they can have their
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// URL's dynamically changes during input switch actions. Presently, this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// functionality only works with MP4_FILE inputs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputSourceType InputSourceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of MediaConnect Flows for this input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MediaConnectFlows []MediaConnectFlow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The user-assigned name (This is a mutable value).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the role this input assumes during and after
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of IDs for all the Input Security Groups attached to the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SecurityGroups []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of the sources of the input (PULL-type).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Sources []InputSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Placeholder documentation for InputState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	State InputState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A collection of key-value pairs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Placeholder documentation for InputType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Type InputType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Placeholder documentation for Input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputAttachment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputAttachment struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// User-specified settings for defining what the conditions are for declaring the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// input unhealthy and failing over to a different input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	AutomaticInputFailoverSettings *AutomaticInputFailoverSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// User-specified name for the attachment. This is required if the user wants to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// use this input in an input switch action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputAttachmentName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The ID of the input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Settings of an input (caption selector, etc.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputSettings *InputSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Placeholder documentation for InputAttachment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputChannelLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputChannelLevel struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Remixing value. Units are in dB and acceptable values are within the range from
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// -60 (mute) and 6 dB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Gain int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The index of the input channel used as a source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputChannel int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Input Channel Level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputClass string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputClassStandard       InputClass = "STANDARD"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputClassSinglePipeline InputClass = "SINGLE_PIPELINE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for InputClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputClass) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputClass) Values() []InputClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for InputClass. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputClippingSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputClippingSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The source of the timecodes in the source being clipped.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InputTimecodeSource InputTimecodeSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Settings to identify the start of the clip.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StartTimecode *StartTimecode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Settings to identify the end of the clip.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StopTimecode *StopTimecode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings to let you create a clip of the file input, in order to set up the input to ingest only a portion of the file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputCodec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputCodec string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputCodecMpeg2 InputCodec = "MPEG2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputCodecAvc   InputCodec = "AVC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputCodecHevc  InputCodec = "HEVC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for InputCodec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (InputCodec) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (InputCodec) Values() []InputCodec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for InputCodec. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputDeblockFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputDeblockFilter string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputDeblockFilterDisabled InputDeblockFilter = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	InputDeblockFilterEnabled  InputDeblockFilter = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for InputDeblockFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (InputDeblockFilter) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for InputDeblockFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDenoiseFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDenoiseFilter string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputDenoiseFilterDisabled InputDenoiseFilter = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputDenoiseFilterEnabled  InputDenoiseFilter = "ENABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for InputDenoiseFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (InputDenoiseFilter) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for InputDenoiseFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InputDestination

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InputDestination struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The system-generated static IP address of endpoint. It remains fixed for the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// lifetime of the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Ip *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The port number for the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Port *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This represents the endpoint that the customer stream will be pushed to.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Url *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The properties for a VPC type input destination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Vpc *InputDestinationVpc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The settings for a PUSH type input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDestinationRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDestinationRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// A unique name for the location the RTMP stream is being pushed to.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StreamName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Endpoint settings for a PUSH type input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDestinationVpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDestinationVpc struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The availability zone of the Input destination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The network interface ID of the Input destination in the VPC.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	NetworkInterfaceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The properties for a VPC type input destination.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputDeviceActiveInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputDeviceActiveInput string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputDeviceActiveInputHdmi InputDeviceActiveInput = "HDMI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputDeviceActiveInputSdi  InputDeviceActiveInput = "SDI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for InputDeviceActiveInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (InputDeviceActiveInput) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for InputDeviceActiveInput. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceConfigurableSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceConfigurableSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The input source that you want to use. If the device has a source connected to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// only one of its input ports, or if you don't care which source the device sends,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// specify Auto. If the device has sources connected to both its input ports, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// you want to use a specific source, specify the source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ConfiguredInput InputDeviceConfiguredInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The maximum bitrate in bits per second. Set a value here to throttle the bitrate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// of the source video.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MaxBitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configurable settings for the input device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDeviceConfiguredInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDeviceConfiguredInput string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputDeviceConfiguredInputAuto InputDeviceConfiguredInput = "AUTO"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputDeviceConfiguredInputHdmi InputDeviceConfiguredInput = "HDMI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InputDeviceConfiguredInputSdi  InputDeviceConfiguredInput = "SDI"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for InputDeviceConfiguredInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (InputDeviceConfiguredInput) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for InputDeviceConfiguredInput. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InputDeviceConnectionState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InputDeviceConnectionState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InputDeviceConnectionStateDisconnected InputDeviceConnectionState = "DISCONNECTED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InputDeviceConnectionStateConnected    InputDeviceConnectionState = "CONNECTED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for InputDeviceConnectionState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (InputDeviceConnectionState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for InputDeviceConnectionState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDeviceHdSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDeviceHdSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// If you specified Auto as the configured input, specifies which of the sources is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// currently active (SDI or HDMI).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ActiveInput InputDeviceActiveInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The source at the input device that is currently active. You can specify this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ConfiguredInput InputDeviceConfiguredInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The state of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DeviceState InputDeviceState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The frame rate of the video source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Framerate float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The height of the video source, in pixels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Height int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The current maximum bitrate for ingesting this source, in bits per second. You
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// can specify this maximum.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	MaxBitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The scan type of the video source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ScanType InputDeviceScanType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The width of the video source, in pixels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Width int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Settings that describe the active source from the input device, and the video characteristics of that source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputDeviceIpScheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputDeviceIpScheme string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputDeviceIpSchemeStatic InputDeviceIpScheme = "STATIC"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputDeviceIpSchemeDhcp   InputDeviceIpScheme = "DHCP"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for InputDeviceIpScheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (InputDeviceIpScheme) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for InputDeviceIpScheme. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceNetworkSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceNetworkSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The DNS addresses of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	DnsAddresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The network gateway IP address.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Gateway *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The IP address of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IpAddress *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Specifies whether the input device has been configured (outside of MediaLive) to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// use a dynamic IP address assignment (DHCP) or a static IP address.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IpScheme InputDeviceIpScheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The subnet mask of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	SubnetMask *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The network settings for the input device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDeviceRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type InputDeviceRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The unique ID for the device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Settings for an input device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputDeviceScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputDeviceScanType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputDeviceScanTypeInterlaced  InputDeviceScanType = "INTERLACED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputDeviceScanTypeProgressive InputDeviceScanType = "PROGRESSIVE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for InputDeviceScanType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputDeviceScanType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for InputDeviceScanType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDeviceSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDeviceSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The unique ID for the device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings for an input device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDeviceState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputDeviceState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputDeviceStateIdle      InputDeviceState = "IDLE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputDeviceStateStreaming InputDeviceState = "STREAMING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for InputDeviceState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (InputDeviceState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for InputDeviceState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputDeviceSummary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputDeviceSummary struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The unique ARN of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The state of the connection between the input device and AWS.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ConnectionState InputDeviceConnectionState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status of the action to synchronize the device configuration. If you change
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// the configuration of the input device (for example, the maximum bitrate),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MediaLive sends the new data to the device. The device might not update itself
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// immediately. SYNCED means the device has updated its configuration. SYNCING
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// means that it has not updated its configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DeviceSettingsSyncState DeviceSettingsSyncState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status of software on the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DeviceUpdateStatus DeviceUpdateStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Settings that describe an input device that is type HD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HdDeviceSettings *InputDeviceHdSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The unique ID of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The network MAC address of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MacAddress *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A name that you specify for the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Network settings for the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	NetworkSettings *InputDeviceNetworkSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The unique serial number of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SerialNumber *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Type InputDeviceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Settings that describe an input device that is type UHD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	UhdDeviceSettings *InputDeviceUhdSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Details of the input device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceTransferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputDeviceTransferType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputDeviceTransferTypeOutgoing InputDeviceTransferType = "OUTGOING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputDeviceTransferTypeIncoming InputDeviceTransferType = "INCOMING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for InputDeviceTransferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (InputDeviceTransferType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for InputDeviceTransferType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputDeviceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputDeviceType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputDeviceTypeHd InputDeviceType = "HD"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for InputDeviceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputDeviceType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputDeviceType) Values() []InputDeviceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for InputDeviceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDeviceUhdSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputDeviceUhdSettings struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// If you specified Auto as the configured input, specifies which of the sources is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// currently active (SDI or HDMI).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ActiveInput InputDeviceActiveInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The source at the input device that is currently active. You can specify this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ConfiguredInput InputDeviceConfiguredInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The state of the input device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DeviceState InputDeviceState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The frame rate of the video source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Framerate float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The height of the video source, in pixels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Height int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The current maximum bitrate for ingesting this source, in bits per second. You
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// can specify this maximum.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	MaxBitrate int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The scan type of the video source.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ScanType InputDeviceScanType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The width of the video source, in pixels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Width int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings that describe the active source from the input device, and the video characteristics of that source.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type InputFilter string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputFilterAuto     InputFilter = "AUTO"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputFilterDisabled InputFilter = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InputFilterForced   InputFilter = "FORCED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for InputFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (InputFilter) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (InputFilter) Values() []InputFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for InputFilter. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InputLocation struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Uniform Resource Identifier - This should be a path to a file accessible to the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Live system (eg. a http:// URI) depending on the output type. For example, a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// RTMP destination should have a uri simliar to: "rtmp://fmsserver/live".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Uri *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// key used to extract the password from EC2 Parameter store
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	PasswordParam *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Documentation update needed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Username *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Input Location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputLossActionForHlsOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InputLossActionForHlsOut string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputLossActionForHlsOutEmitOutput  InputLossActionForHlsOut = "EMIT_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InputLossActionForHlsOutPauseOutput InputLossActionForHlsOut = "PAUSE_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for InputLossActionForHlsOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (InputLossActionForHlsOut) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for InputLossActionForHlsOut. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputLossActionForMsSmoothOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InputLossActionForMsSmoothOut string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputLossActionForMsSmoothOutEmitOutput  InputLossActionForMsSmoothOut = "EMIT_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	InputLossActionForMsSmoothOutPauseOutput InputLossActionForMsSmoothOut = "PAUSE_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enum values for InputLossActionForMsSmoothOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (InputLossActionForMsSmoothOut) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Values returns all known values for InputLossActionForMsSmoothOut. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputLossActionForRtmpOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type InputLossActionForRtmpOut string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InputLossActionForRtmpOutEmitOutput  InputLossActionForRtmpOut = "EMIT_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InputLossActionForRtmpOutPauseOutput InputLossActionForRtmpOut = "PAUSE_OUTPUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for InputLossActionForRtmpOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (InputLossActionForRtmpOut) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for InputLossActionForRtmpOut. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputLossActionForUdpOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InputLossActionForUdpOut string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputLossActionForUdpOutDropProgram InputLossActionForUdpOut = "DROP_PROGRAM"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputLossActionForUdpOutDropTs      InputLossActionForUdpOut = "DROP_TS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InputLossActionForUdpOutEmitProgram