type ClientLimitExceededException struct {
	Message *string
}

type ClipFragmentSelector struct {

	// The range of timestamps to return.
	//
	// This member is required.
	TimestampRange *ClipTimestampRange

	// The origin of the timestamps to use (Server or Producer).
	//
	// This member is required.
	FragmentSelectorType ClipFragmentSelectorType
}

type ClipFragmentSelectorType string

const (
	ClipFragmentSelectorTypeProducer_timestamp ClipFragmentSelectorType = "PRODUCER_TIMESTAMP"
	ClipFragmentSelectorTypeServer_timestamp   ClipFragmentSelectorType = "SERVER_TIMESTAMP"
)

type ClipTimestampRange struct {

	// The starting timestamp in the range of timestamps for which to return fragments.
	// This value is inclusive. Fragments that start before the StartTimestamp and
	// continue past it are included in the session. If FragmentSelectorType is
	// SERVER_TIMESTAMP, the StartTimestamp must be later than the stream head.
	//
	// This member is required.
	StartTimestamp *time.Time

	// The end of the timestamp range for the requested media. This value must be
	// within 3 hours of the specified StartTimestamp, and it must be later than the
	// StartTimestamp value. If FragmentSelectorType for the request is
	// SERVER_TIMESTAMP, this value must be in the past. This value is inclusive. The
	// EndTimestamp is compared to the (starting) timestamp of the fragment. Fragments
	// that start before the EndTimestamp value and continue past it are included in
	// the session.
	//
	// This member is required.
	EndTimestamp *time.Time
}

type ContainerFormat string

const (
	ContainerFormatFragmented_mp4 ContainerFormat = "FRAGMENTED_MP4"
	ContainerFormatMpeg_ts        ContainerFormat = "MPEG_TS"
)

type DASHDisplayFragmentNumber string

const (
	DASHDisplayFragmentNumberAlways DASHDisplayFragmentNumber = "ALWAYS"
	DASHDisplayFragmentNumberNever  DASHDisplayFragmentNumber = "NEVER"
)

type DASHDisplayFragmentTimestamp string

const (
	DASHDisplayFragmentTimestampAlways DASHDisplayFragmentTimestamp = "ALWAYS"
	DASHDisplayFragmentTimestampNever  DASHDisplayFragmentTimestamp = "NEVER"
)

type DASHFragmentSelector struct {

	// The start and end of the timestamp range for the requested media. This value
	// should not be present if PlaybackType is LIVE.
	TimestampRange *DASHTimestampRange

	// The source of the timestamps for the requested media. When FragmentSelectorType
	// is set to PRODUCER_TIMESTAMP and GetDASHStreamingSessionURLInput$PlaybackMode ()
	// is ON_DEMAND or LIVE_REPLAY, the first fragment ingested with a producer
	// timestamp within the specified FragmentSelector$TimestampRange () is included in
	// the media playlist. In addition, the fragments with producer timestamps within
	// the TimestampRange ingested immediately following the first fragment (up to the
	// GetDASHStreamingSessionURLInput$MaxManifestFragmentResults () value) are
	// included. Fragments that have duplicate producer timestamps are deduplicated.
	// This means that if producers are producing a stream of fragments with producer
	// timestamps that are approximately equal to the true clock time, the MPEG-DASH
	// manifest will contain all of the fragments within the requested timestamp range.
	// If some fragments are ingested within the same time range and very different
	// points in time, only the oldest ingested collection of fragments are returned.
	// When FragmentSelectorType is set to PRODUCER_TIMESTAMP and
	// GetDASHStreamingSessionURLInput$PlaybackMode () is LIVE, the producer timestamps
	// are used in the MP4 fragments and for deduplication. But the most recently
	// ingested fragments based on server timestamps are included in the MPEG-DASH
	// manifest. This means that even if fragments ingested in the past have producer
	// timestamps with values now, they are not included in the HLS media playlist. The
	// default is SERVER_TIMESTAMP.
	FragmentSelectorType DASHFragmentSelectorType
}

type DASHFragmentSelectorType string

const (
	DASHFragmentSelectorTypeProducer_timestamp DASHFragmentSelectorType = "PRODUCER_TIMESTAMP"
	DASHFragmentSelectorTypeServer_timestamp   DASHFragmentSelectorType = "SERVER_TIMESTAMP"
)

type DASHPlaybackMode string

const (
	DASHPlaybackModeLive        DASHPlaybackMode = "LIVE"
	DASHPlaybackModeLive_replay DASHPlaybackMode = "LIVE_REPLAY"
	DASHPlaybackModeOn_demand   DASHPlaybackMode = "ON_DEMAND"
)

type DASHTimestampRange struct {

	// The start of the timestamp range for the requested media. If the
	// DASHTimestampRange value is specified, the StartTimestamp value is required.
	// This value is inclusive. Fragments that start before the StartTimestamp and
	// continue past it are included in the session. If FragmentSelectorType is
	// SERVER_TIMESTAMP, the StartTimestamp must be later than the stream head.
	StartTimestamp *time.Time

	// The end of the timestamp range for the requested media. This value must be
	// within 3 hours of the specified StartTimestamp, and it must be later than the
	// StartTimestamp value. If FragmentSelectorType for the request is
	// SERVER_TIMESTAMP, this value must be in the past.  <p>The
	// <code>EndTimestamp</code> value is required for <code>ON_DEMAND</code> mode, but
	// optional for <code>LIVE_REPLAY</code> mode. If the <code>EndTimestamp</code> is
	// not set for <code>LIVE_REPLAY</code> mode then the session will continue to
	// include newly ingested fragments until the session expires.</p> <note> <p>This
	// value is inclusive. The <code>EndTimestamp</code> is compared to the (starting)
	// timestamp of the fragment. Fragments that start before the
	// <code>EndTimestamp</code> value and continue past it are included in the
	// session.</p> </note>
	EndTimestamp *time.Time
}

type Fragment struct {

	// The timestamp from the AWS server corresponding to the fragment.
	ServerTimestamp *time.Time

	// The playback duration or other time value associated with the fragment.
	FragmentLengthInMilliseconds *int64

	// The total fragment size, including information about the fragment and contained
	// media data.
	FragmentSizeInBytes *int64

	// The unique identifier of the fragment. This value monotonically increases based
	// on the ingestion order.
	FragmentNumber *string

	// The timestamp from the producer corresponding to the fragment.
	ProducerTimestamp *time.Time
}

type FragmentSelector struct {

	// The origin of the timestamps to use (Server or Producer).
	//
	// This member is required.
	FragmentSelectorType FragmentSelectorType

	// The range of timestamps to return.
	//
	// This member is required.
	TimestampRange *TimestampRange
}

type FragmentSelectorType string

const (
	FragmentSelectorTypeProducer_timestamp FragmentSelectorType = "PRODUCER_TIMESTAMP"
	FragmentSelectorTypeServer_timestamp   FragmentSelectorType = "SERVER_TIMESTAMP"
)

type HLSDiscontinuityMode string

const (
	HLSDiscontinuityModeAlways           HLSDiscontinuityMode = "ALWAYS"
	HLSDiscontinuityModeNever            HLSDiscontinuityMode = "NEVER"
	HLSDiscontinuityModeOn_discontinuity HLSDiscontinuityMode = "ON_DISCONTINUITY"
)

type HLSDisplayFragmentTimestamp string

const (
	HLSDisplayFragmentTimestampAlways HLSDisplayFragmentTimestamp = "ALWAYS"
	HLSDisplayFragmentTimestampNever  HLSDisplayFragmentTimestamp = "NEVER"
)

type HLSFragmentSelector struct {

	// The start and end of the timestamp range for the requested media. This value
	// should not be present if PlaybackType is LIVE.
	TimestampRange *HLSTimestampRange

	// The source of the timestamps for the requested media. When FragmentSelectorType
	// is set to PRODUCER_TIMESTAMP and GetHLSStreamingSessionURLInput$PlaybackMode ()
	// is ON_DEMAND or LIVE_REPLAY, the first fragment ingested with a producer
	// timestamp within the specified FragmentSelector$TimestampRange () is included in
	// the media playlist. In addition, the fragments with producer timestamps within
	// the TimestampRange ingested immediately following the first fragment (up to the
	// GetHLSStreamingSessionURLInput$MaxMediaPlaylistFragmentResults () value) are
	// included. Fragments that have duplicate producer timestamps are deduplicated.
	// This means that if producers are producing a stream of fragments with producer
	// timestamps that are approximately equal to the true clock time, the HLS media
	// playlists will contain all of the fragments within the requested timestamp
	// range. If some fragments are ingested within the same time range and very
	// different points in time, only the oldest ingested collection of fragments are
	// returned. When FragmentSelectorType is set to PRODUCER_TIMESTAMP and
	// GetHLSStreamingSessionURLInput$PlaybackMode () is LIVE, the producer timestamps
	// are used in the MP4 fragments and for deduplication. But the most recently
	// ingested fragments based on server timestamps are included in the HLS media
	// playlist. This means that even if fragments ingested in the past have producer
	// timestamps with values now, they are not included in the HLS media playlist. The
	// default is SERVER_TIMESTAMP.
	FragmentSelectorType HLSFragmentSelectorType
}

type HLSFragmentSelectorType string

const (
	HLSFragmentSelectorTypeProducer_timestamp HLSFragmentSelectorType = "PRODUCER_TIMESTAMP"
	HLSFragmentSelectorTypeServer_timestamp   HLSFragmentSelectorType = "SERVER_TIMESTAMP"
)

type HLSPlaybackMode string

const (
	HLSPlaybackModeLive        HLSPlaybackMode = "LIVE"
	HLSPlaybackModeLive_replay HLSPlaybackMode = "LIVE_REPLAY"
	HLSPlaybackModeOn_demand   HLSPlaybackMode = "ON_DEMAND"
)

type HLSTimestampRange struct {

	// The start of the timestamp range for the requested media. If the
	// HLSTimestampRange value is specified, the StartTimestamp value is required. This
	// value is inclusive. Fragments that start before the StartTimestamp and continue
	// past it are included in the session. If FragmentSelectorType is
	// SERVER_TIMESTAMP, the StartTimestamp must be later than the stream head.
	StartTimestamp *time.Time

	// The end of the timestamp range for the requested media. This value must be
	// within 3 hours of the specified StartTimestamp, and it must be later than the
	// StartTimestamp value. If FragmentSelectorType for the request is
	// SERVER_TIMESTAMP, this value must be in the past. The EndTimestamp value is
	// required for ON_DEMAND mode, but optional for LIVE_REPLAY mode. If the
	// EndTimestamp is not set for LIVE_REPLAY mode then the session will continue to
	// include newly ingested fragments until the session expires. This value is
	// inclusive. The EndTimestamp is compared to the (starting) timestamp of the
	// fragment. Fragments that start before the EndTimestamp value and continue past
	// it are included in the session.
	EndTimestamp *time.Time
}

type InvalidArgumentException struct {
	Message *string
}

type InvalidCodecPrivateDataException struct {
	Message *string
}

type InvalidMediaFrameException struct {
	Message *string
}

type MissingCodecPrivateDataException struct {
	Message *string
}

type NoDataRetentionException struct {
	Message *string
}

type NotAuthorizedException struct {
	Message *string
}

type ResourceNotFoundException struct {
	Message *string
}

type TimestampRange struct {

	// The starting timestamp in the range of timestamps for which to return fragments.
	//
	// This member is required.
	StartTimestamp *time.Time

	// The ending timestamp in the range of timestamps for which to return fragments.
	//
	// This member is required.
	EndTimestamp *time.Time
}

type UnsupportedStreamMediaTypeException struct {
	Message *string
}