/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include namespace Aws { namespace KinesisVideoArchivedMedia { namespace Model { /** */ class GetDASHStreamingSessionURLRequest : public KinesisVideoArchivedMediaRequest { public: AWS_KINESISVIDEOARCHIVEDMEDIA_API GetDASHStreamingSessionURLRequest(); // Service request name is the Operation name which will send this request out, // each operation should has unique request name, so that we can get operation's name from this request. // Note: this is not true for response, multiple operations may have the same response name, // so we can not get operation's name from response. inline virtual const char* GetServiceRequestName() const override { return "GetDASHStreamingSessionURL"; } AWS_KINESISVIDEOARCHIVEDMEDIA_API Aws::String SerializePayload() const override; /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline const Aws::String& GetStreamName() const{ return m_streamName; } /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; } /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline void SetStreamName(const Aws::String& value) { m_streamNameHasBeenSet = true; m_streamName = value; } /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline void SetStreamName(Aws::String&& value) { m_streamNameHasBeenSet = true; m_streamName = std::move(value); } /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline void SetStreamName(const char* value) { m_streamNameHasBeenSet = true; m_streamName.assign(value); } /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamName(const Aws::String& value) { SetStreamName(value); return *this;} /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamName(Aws::String&& value) { SetStreamName(std::move(value)); return *this;} /** *

The name of the stream for which to retrieve the MPEG-DASH manifest URL.

You must specify either the StreamName or the * StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamName(const char* value) { SetStreamName(value); return *this;} /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline const Aws::String& GetStreamARN() const{ return m_streamARN; } /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline bool StreamARNHasBeenSet() const { return m_streamARNHasBeenSet; } /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline void SetStreamARN(const Aws::String& value) { m_streamARNHasBeenSet = true; m_streamARN = value; } /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline void SetStreamARN(Aws::String&& value) { m_streamARNHasBeenSet = true; m_streamARN = std::move(value); } /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline void SetStreamARN(const char* value) { m_streamARNHasBeenSet = true; m_streamARN.assign(value); } /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamARN(const Aws::String& value) { SetStreamARN(value); return *this;} /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamARN(Aws::String&& value) { SetStreamARN(std::move(value)); return *this;} /** *

The Amazon Resource Name (ARN) of the stream for which to retrieve the * MPEG-DASH manifest URL.

You must specify either the * StreamName or the StreamARN.

*/ inline GetDASHStreamingSessionURLRequest& WithStreamARN(const char* value) { SetStreamARN(value); return *this;} /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

In all playback * modes, if FragmentSelectorType is PRODUCER_TIMESTAMP, * and if there are multiple fragments with the same start timestamp, the fragment * that has the larger fragment number (that is, the newer fragment) is included in * the MPEG-DASH manifest. The other fragments are not included. Fragments that * have different timestamps but have overlapping durations are still included in * the MPEG-DASH manifest. This can lead to unexpected behavior in the media * player.

The default is LIVE.

*/ inline const DASHPlaybackMode& GetPlaybackMode() const{ return m_playbackMode; } /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

The default is LIVE.

*/ inline bool PlaybackModeHasBeenSet() const { return m_playbackModeHasBeenSet; } /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

The default is LIVE.

*/ inline void SetPlaybackMode(const DASHPlaybackMode& value) { m_playbackModeHasBeenSet = true; m_playbackMode = value; } /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

The default is LIVE.

*/ inline void SetPlaybackMode(DASHPlaybackMode&& value) { m_playbackModeHasBeenSet = true; m_playbackMode = std::move(value); } /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

The default is LIVE.

*/ inline GetDASHStreamingSessionURLRequest& WithPlaybackMode(const DASHPlaybackMode& value) { SetPlaybackMode(value); return *this;} /** *

Whether to retrieve live, live replay, or archived, on-demand data.

Features of the three types of sessions include the following:

*
LIVE : For sessions of this type, the MPEG-DASH * manifest is continually updated with the latest fragments as they become * available. We recommend that the media player retrieve a new manifest on a * one-second interval. When this type of session is played in a media player, the * user interface typically displays a "live" notification, with no scrubber * control for choosing the position in the playback window to display.
*
In LIVE mode, the newest available fragments are included in an * MPEG-DASH manifest, even if there is a gap between fragments (that is, if a * fragment is missing). A gap like this might cause a media player to halt or * cause a jump in playback. In this mode, fragments are not added to the MPEG-DASH * manifest if they are older than the newest fragment in the playlist. If the * missing fragment becomes available after a subsequent fragment is added to the * manifest, the older fragment is not added, and the gap is not filled.
*
LIVE_REPLAY : For sessions of this * type, the MPEG-DASH manifest is updated similarly to how it is updated for * LIVE mode except that it starts by including fragments from a given * start time. Instead of fragments being added as they are ingested, fragments are * added as the duration of the next fragment elapses. For example, if the * fragments in the session are two seconds long, then a new fragment is added to * the manifest every two seconds. This mode is useful to be able to start playback * from when an event is detected and continue live streaming media that has not * yet been ingested as of the time of the session creation. This mode is also * useful to stream previously archived media without being limited by the 1,000 * fragment limit in the ON_DEMAND mode.
* ON_DEMAND : For sessions of this type, the MPEG-DASH manifest * contains all the fragments for the session, up to the number that is specified * in MaxManifestFragmentResults. The manifest must be retrieved only * once for each session. When this type of session is played in a media player, * the user interface typically displays a scrubber control for choosing the * position in the playback window to display.

The default is LIVE.

*/ inline GetDASHStreamingSessionURLRequest& WithPlaybackMode(DASHPlaybackMode&& value) { SetPlaybackMode(std::move(value)); return *this;} /** *

Per the MPEG-DASH specification, the wall-clock time of fragments in the * manifest file can be derived using attributes in the manifest itself. However, * typically, MPEG-DASH compatible media players do not properly handle gaps in the * media timeline. Kinesis Video Streams adjusts the media timeline in the manifest * file to enable playback of media with discontinuities. Therefore, the wall-clock * time derived from the manifest file may be inaccurate. If * DisplayFragmentTimestamp is set to ALWAYS, the accurate fragment * timestamp is added to each S element in the manifest file with the attribute * name “kvs:ts”. A custom MPEG-DASH media player is necessary to leverage this * custom attribute.

The default value is NEVER. When * DASHFragmentSelector is SERVER_TIMESTAMP, the timestamps * will be the server start timestamps. Similarly, when DASHFragmentSelector * is PRODUCER_TIMESTAMP, the timestamps will be the producer start * timestamps.

*/ inline const DASHDisplayFragmentTimestamp& GetDisplayFragmentTimestamp() const{ return m_displayFragmentTimestamp; } /** *

*/ inline bool DisplayFragmentTimestampHasBeenSet() const { return m_displayFragmentTimestampHasBeenSet; } /** *

*/ inline void SetDisplayFragmentTimestamp(const DASHDisplayFragmentTimestamp& value) { m_displayFragmentTimestampHasBeenSet = true; m_displayFragmentTimestamp = value; } /** *

*/ inline void SetDisplayFragmentTimestamp(DASHDisplayFragmentTimestamp&& value) { m_displayFragmentTimestampHasBeenSet = true; m_displayFragmentTimestamp = std::move(value); } /** *

*/ inline GetDASHStreamingSessionURLRequest& WithDisplayFragmentTimestamp(const DASHDisplayFragmentTimestamp& value) { SetDisplayFragmentTimestamp(value); return *this;} /** *

*/ inline GetDASHStreamingSessionURLRequest& WithDisplayFragmentTimestamp(DASHDisplayFragmentTimestamp&& value) { SetDisplayFragmentTimestamp(std::move(value)); return *this;} /** *

Fragments are identified in the manifest file based on their sequence number * in the session. If DisplayFragmentNumber is set to ALWAYS, the * Kinesis Video Streams fragment number is added to each S element in the manifest * file with the attribute name “kvs:fn”. These fragment numbers can be used for * logging or for use with other APIs (e.g. GetMedia and * GetMediaForFragmentList). A custom MPEG-DASH media player is * necessary to leverage these this custom attribute.

The default value is * NEVER.

*/ inline const DASHDisplayFragmentNumber& GetDisplayFragmentNumber() const{ return m_displayFragmentNumber; } /** *

The default value is * NEVER.

*/ inline bool DisplayFragmentNumberHasBeenSet() const { return m_displayFragmentNumberHasBeenSet; } /** *

The default value is * NEVER.

*/ inline void SetDisplayFragmentNumber(const DASHDisplayFragmentNumber& value) { m_displayFragmentNumberHasBeenSet = true; m_displayFragmentNumber = value; } /** *

The default value is * NEVER.

*/ inline void SetDisplayFragmentNumber(DASHDisplayFragmentNumber&& value) { m_displayFragmentNumberHasBeenSet = true; m_displayFragmentNumber = std::move(value); } /** *

The default value is * NEVER.

*/ inline GetDASHStreamingSessionURLRequest& WithDisplayFragmentNumber(const DASHDisplayFragmentNumber& value) { SetDisplayFragmentNumber(value); return *this;} /** *

The default value is * NEVER.

*/ inline GetDASHStreamingSessionURLRequest& WithDisplayFragmentNumber(DASHDisplayFragmentNumber&& value) { SetDisplayFragmentNumber(std::move(value)); return *this;} /** *

The time range of the requested fragment and the source of the * timestamps.

This parameter is required if PlaybackMode is * ON_DEMAND or LIVE_REPLAY. This parameter is optional * if PlaybackMode isLIVE. If PlaybackMode is * LIVE, the FragmentSelectorType can be set, but the * TimestampRange should not be set. If PlaybackMode is * ON_DEMAND or LIVE_REPLAY, both * FragmentSelectorType and TimestampRange must be * set.


     */
    inline const DASHFragmentSelector& GetDASHFragmentSelector() const{ return m_dASHFragmentSelector; }

    /**
     * The time range of the requested fragment and the source of the
     * timestamps.
 This parameter is required if PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY. This parameter is optional
     * if PlaybackMode is LIVE. If PlaybackMode is
     * LIVE, the FragmentSelectorType can be set, but the
     * TimestampRange should not be set. If PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY, both
     * FragmentSelectorType and TimestampRange must be
     * set.

     */
    inline bool DASHFragmentSelectorHasBeenSet() const { return m_dASHFragmentSelectorHasBeenSet; }

    /**
     * The time range of the requested fragment and the source of the
     * timestamps.
 This parameter is required if PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY. This parameter is optional
     * if PlaybackMode is LIVE. If PlaybackMode is
     * LIVE, the FragmentSelectorType can be set, but the
     * TimestampRange should not be set. If PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY, both
     * FragmentSelectorType and TimestampRange must be
     * set.

     */
    inline void SetDASHFragmentSelector(const DASHFragmentSelector& value) { m_dASHFragmentSelectorHasBeenSet = true; m_dASHFragmentSelector = value; }

    /**
     * The time range of the requested fragment and the source of the
     * timestamps.
 This parameter is required if PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY. This parameter is optional
     * if PlaybackMode is LIVE. If PlaybackMode is
     * LIVE, the FragmentSelectorType can be set, but the
     * TimestampRange should not be set. If PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY, both
     * FragmentSelectorType and TimestampRange must be
     * set.

     */
    inline void SetDASHFragmentSelector(DASHFragmentSelector&& value) { m_dASHFragmentSelectorHasBeenSet = true; m_dASHFragmentSelector = std::move(value); }

    /**
     * The time range of the requested fragment and the source of the
     * timestamps.
 This parameter is required if PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY. This parameter is optional
     * if PlaybackMode is LIVE. If PlaybackMode is
     * LIVE, the FragmentSelectorType can be set, but the
     * TimestampRange should not be set. If PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY, both
     * FragmentSelectorType and TimestampRange must be
     * set.

     */
    inline GetDASHStreamingSessionURLRequest& WithDASHFragmentSelector(const DASHFragmentSelector& value) { SetDASHFragmentSelector(value); return *this;}

    /**
     * The time range of the requested fragment and the source of the
     * timestamps.
 This parameter is required if PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY. This parameter is optional
     * if PlaybackMode is LIVE. If PlaybackMode is
     * LIVE, the FragmentSelectorType can be set, but the
     * TimestampRange should not be set. If PlaybackMode is
     * ON_DEMAND or LIVE_REPLAY, both
     * FragmentSelectorType and TimestampRange must be
     * set.

     */
    inline GetDASHStreamingSessionURLRequest& WithDASHFragmentSelector(DASHFragmentSelector&& value) { SetDASHFragmentSelector(std::move(value)); return *this;}


    /**
     * The time in seconds until the requested session expires. This value can be
     * between 300 (5 minutes) and 43200 (12 hours).
 When a session expires, no
     * new calls to GetDashManifest, GetMP4InitFragment, or
     * GetMP4MediaFragment can be made for that session.
 The
     * default is 300 (5 minutes).
     */
    inline int GetExpires() const{ return m_expires; }

    /**
     * The time in seconds until the requested session expires. This value can be
     * between 300 (5 minutes) and 43200 (12 hours).
 When a session expires, no
     * new calls to GetDashManifest, GetMP4InitFragment, or
     * GetMP4MediaFragment can be made for that session.
 The
     * default is 300 (5 minutes).
     */
    inline bool ExpiresHasBeenSet() const { return m_expiresHasBeenSet; }

    /**
     * The time in seconds until the requested session expires. This value can be
     * between 300 (5 minutes) and 43200 (12 hours).
 When a session expires, no
     * new calls to GetDashManifest, GetMP4InitFragment, or
     * GetMP4MediaFragment can be made for that session.
 The
     * default is 300 (5 minutes).
     */
    inline void SetExpires(int value) { m_expiresHasBeenSet = true; m_expires = value; }

    /**
     * The time in seconds until the requested session expires. This value can be
     * between 300 (5 minutes) and 43200 (12 hours).
 When a session expires, no
     * new calls to GetDashManifest, GetMP4InitFragment, or
     * GetMP4MediaFragment can be made for that session.
 The
     * default is 300 (5 minutes).
     */
    inline GetDASHStreamingSessionURLRequest& WithExpires(int value) { SetExpires(value); return *this;}


    /**
     * The maximum number of fragments that are returned in the MPEG-DASH
     * manifest.
 When the PlaybackMode is LIVE, the
     * most recent fragments are returned up to this value. When the
     * PlaybackMode is ON_DEMAND, the oldest fragments are
     * returned, up to this maximum number.
 When there are a higher number of
     * fragments available in a live MPEG-DASH manifest, video players often buffer
     * content before starting playback. Increasing the buffer size increases the
     * playback latency, but it decreases the likelihood that rebuffering will occur
     * during playback. We recommend that a live MPEG-DASH manifest have a minimum of 3
     * fragments and a maximum of 10 fragments.
 The default is 5 fragments if
     * PlaybackMode is LIVE or LIVE_REPLAY, and
     * 1,000 if PlaybackMode is ON_DEMAND. 
 The
     * maximum value of 1,000 fragments corresponds to more than 16 minutes of video on
     * streams with 1-second fragments, and more than 2 1/2 hours of video on streams
     * with 10-second fragments.
     */
    inline long long GetMaxManifestFragmentResults() const{ return m_maxManifestFragmentResults; }

    /**
     * The maximum number of fragments that are returned in the MPEG-DASH
     * manifest.
 When the PlaybackMode is LIVE, the
     * most recent fragments are returned up to this value. When the
     * PlaybackMode is ON_DEMAND, the oldest fragments are
     * returned, up to this maximum number.
 When there are a higher number of
     * fragments available in a live MPEG-DASH manifest, video players often buffer
     * content before starting playback. Increasing the buffer size increases the
     * playback latency, but it decreases the likelihood that rebuffering will occur
     * during playback. We recommend that a live MPEG-DASH manifest have a minimum of 3
     * fragments and a maximum of 10 fragments.
 The default is 5 fragments if
     * PlaybackMode is LIVE or LIVE_REPLAY, and
     * 1,000 if PlaybackMode is ON_DEMAND. 
 The
     * maximum value of 1,000 fragments corresponds to more than 16 minutes of video on
     * streams with 1-second fragments, and more than 2 1/2 hours of video on streams
     * with 10-second fragments.
     */
    inline bool MaxManifestFragmentResultsHasBeenSet() const { return m_maxManifestFragmentResultsHasBeenSet; }

    /**
     * The maximum number of fragments that are returned in the MPEG-DASH
     * manifest.
 When the PlaybackMode is LIVE, the
     * most recent fragments are returned up to this value. When the
     * PlaybackMode is ON_DEMAND, the oldest fragments are
     * returned, up to this maximum number.
 When there are a higher number of
     * fragments available in a live MPEG-DASH manifest, video players often buffer
     * content before starting playback. Increasing the buffer size increases the
     * playback latency, but it decreases the likelihood that rebuffering will occur
     * during playback. We recommend that a live MPEG-DASH manifest have a minimum of 3
     * fragments and a maximum of 10 fragments.
 The default is 5 fragments if
     * PlaybackMode is LIVE or LIVE_REPLAY, and
     * 1,000 if PlaybackMode is ON_DEMAND. 
 The
     * maximum value of 1,000 fragments corresponds to more than 16 minutes of video on
     * streams with 1-second fragments, and more than 2 1/2 hours of video on streams
     * with 10-second fragments.
     */
    inline void SetMaxManifestFragmentResults(long long value) { m_maxManifestFragmentResultsHasBeenSet = true; m_maxManifestFragmentResults = value; }

    /**
     * The maximum number of fragments that are returned in the MPEG-DASH
     * manifest.
 When the PlaybackMode is LIVE, the
     * most recent fragments are returned up to this value. When the
     * PlaybackMode is ON_DEMAND, the oldest fragments are
     * returned, up to this maximum number.
 When there are a higher number of
     * fragments available in a live MPEG-DASH manifest, video players often buffer
     * content before starting playback. Increasing the buffer size increases the
     * playback latency, but it decreases the likelihood that rebuffering will occur
     * during playback. We recommend that a live MPEG-DASH manifest have a minimum of 3
     * fragments and a maximum of 10 fragments.
 The default is 5 fragments if
     * PlaybackMode is LIVE or LIVE_REPLAY, and
     * 1,000 if PlaybackMode is ON_DEMAND. 
 The
     * maximum value of 1,000 fragments corresponds to more than 16 minutes of video on
     * streams with 1-second fragments, and more than 2 1/2 hours of video on streams
     * with 10-second fragments.
     */
    inline GetDASHStreamingSessionURLRequest& WithMaxManifestFragmentResults(long long value) { SetMaxManifestFragmentResults(value); return *this;}

  private:

    Aws::String m_streamName;
    bool m_streamNameHasBeenSet = false;

    Aws::String m_streamARN;
    bool m_streamARNHasBeenSet = false;

    DASHPlaybackMode m_playbackMode;
    bool m_playbackModeHasBeenSet = false;

    DASHDisplayFragmentTimestamp m_displayFragmentTimestamp;
    bool m_displayFragmentTimestampHasBeenSet = false;

    DASHDisplayFragmentNumber m_displayFragmentNumber;
    bool m_displayFragmentNumberHasBeenSet = false;

    DASHFragmentSelector m_dASHFragmentSelector;
    bool m_dASHFragmentSelectorHasBeenSet = false;

    int m_expires;
    bool m_expiresHasBeenSet = false;

    long long m_maxManifestFragmentResults;
    bool m_maxManifestFragmentResultsHasBeenSet = false;
  };

} // namespace Model
} // namespace KinesisVideoArchivedMedia
} // namespace Aws