aws-sdk-kinesisvideoarchivedmedia 1.16.0 → 1.21.0

data/lib/aws-sdk-kinesisvideoarchivedmedia/client_api.rb

@@ -14,8 +14,13 @@ module Aws::KinesisVideoArchivedMedia
     ClientLimitExceededException = Shapes::StructureShape.new(name: 'ClientLimitExceededException')
     ContainerFormat = Shapes::StringShape.new(name: 'ContainerFormat')
     ContentType = Shapes::StringShape.new(name: 'ContentType')
-    DiscontinuityMode = Shapes::StringShape.new(name: 'DiscontinuityMode')
-    DisplayFragmentTimestamp = Shapes::StringShape.new(name: 'DisplayFragmentTimestamp')
+    DASHDisplayFragmentNumber = Shapes::StringShape.new(name: 'DASHDisplayFragmentNumber')
+    DASHDisplayFragmentTimestamp = Shapes::StringShape.new(name: 'DASHDisplayFragmentTimestamp')
+    DASHFragmentSelector = Shapes::StructureShape.new(name: 'DASHFragmentSelector')
+    DASHFragmentSelectorType = Shapes::StringShape.new(name: 'DASHFragmentSelectorType')
+    DASHPlaybackMode = Shapes::StringShape.new(name: 'DASHPlaybackMode')
+    DASHStreamingSessionURL = Shapes::StringShape.new(name: 'DASHStreamingSessionURL')
+    DASHTimestampRange = Shapes::StructureShape.new(name: 'DASHTimestampRange')
     ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
     Expires = Shapes::IntegerShape.new(name: 'Expires')
     Fragment = Shapes::StructureShape.new(name: 'Fragment')
@@ -24,12 +29,17 @@ module Aws::KinesisVideoArchivedMedia
     FragmentNumberString = Shapes::StringShape.new(name: 'FragmentNumberString')
     FragmentSelector = Shapes::StructureShape.new(name: 'FragmentSelector')
     FragmentSelectorType = Shapes::StringShape.new(name: 'FragmentSelectorType')
+    GetDASHStreamingSessionURLInput = Shapes::StructureShape.new(name: 'GetDASHStreamingSessionURLInput')
+    GetDASHStreamingSessionURLOutput = Shapes::StructureShape.new(name: 'GetDASHStreamingSessionURLOutput')
     GetHLSStreamingSessionURLInput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLInput')
     GetHLSStreamingSessionURLOutput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLOutput')
     GetMediaForFragmentListInput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListInput')
     GetMediaForFragmentListOutput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListOutput')
+    HLSDiscontinuityMode = Shapes::StringShape.new(name: 'HLSDiscontinuityMode')
+    HLSDisplayFragmentTimestamp = Shapes::StringShape.new(name: 'HLSDisplayFragmentTimestamp')
     HLSFragmentSelector = Shapes::StructureShape.new(name: 'HLSFragmentSelector')
     HLSFragmentSelectorType = Shapes::StringShape.new(name: 'HLSFragmentSelectorType')
+    HLSPlaybackMode = Shapes::StringShape.new(name: 'HLSPlaybackMode')
     HLSStreamingSessionURL = Shapes::StringShape.new(name: 'HLSStreamingSessionURL')
     HLSTimestampRange = Shapes::StructureShape.new(name: 'HLSTimestampRange')
     InvalidArgumentException = Shapes::StructureShape.new(name: 'InvalidArgumentException')
@@ -42,7 +52,6 @@ module Aws::KinesisVideoArchivedMedia
     NotAuthorizedException = Shapes::StructureShape.new(name: 'NotAuthorizedException')
     PageLimit = Shapes::IntegerShape.new(name: 'PageLimit')
     Payload = Shapes::BlobShape.new(name: 'Payload', streaming: true)
-    PlaybackMode = Shapes::StringShape.new(name: 'PlaybackMode')
     ResourceARN = Shapes::StringShape.new(name: 'ResourceARN')
     ResourceNotFoundException = Shapes::StructureShape.new(name: 'ResourceNotFoundException')
     StreamName = Shapes::StringShape.new(name: 'StreamName')
@@ -54,6 +63,14 @@ module Aws::KinesisVideoArchivedMedia
     ClientLimitExceededException.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "Message"))
     ClientLimitExceededException.struct_class = Types::ClientLimitExceededException
 
+    DASHFragmentSelector.add_member(:fragment_selector_type, Shapes::ShapeRef.new(shape: DASHFragmentSelectorType, location_name: "FragmentSelectorType"))
+    DASHFragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: DASHTimestampRange, location_name: "TimestampRange"))
+    DASHFragmentSelector.struct_class = Types::DASHFragmentSelector
+
+    DASHTimestampRange.add_member(:start_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartTimestamp"))
+    DASHTimestampRange.add_member(:end_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EndTimestamp"))
+    DASHTimestampRange.struct_class = Types::DASHTimestampRange
+
     Fragment.add_member(:fragment_number, Shapes::ShapeRef.new(shape: String, location_name: "FragmentNumber"))
     Fragment.add_member(:fragment_size_in_bytes, Shapes::ShapeRef.new(shape: Long, location_name: "FragmentSizeInBytes"))
     Fragment.add_member(:producer_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "ProducerTimestamp"))
@@ -69,13 +86,26 @@ module Aws::KinesisVideoArchivedMedia
     FragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: TimestampRange, required: true, location_name: "TimestampRange"))
     FragmentSelector.struct_class = Types::FragmentSelector
 
+    GetDASHStreamingSessionURLInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
+    GetDASHStreamingSessionURLInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: ResourceARN, location_name: "StreamARN"))
+    GetDASHStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: DASHPlaybackMode, location_name: "PlaybackMode"))
+    GetDASHStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: DASHDisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
+    GetDASHStreamingSessionURLInput.add_member(:display_fragment_number, Shapes::ShapeRef.new(shape: DASHDisplayFragmentNumber, location_name: "DisplayFragmentNumber"))
+    GetDASHStreamingSessionURLInput.add_member(:dash_fragment_selector, Shapes::ShapeRef.new(shape: DASHFragmentSelector, location_name: "DASHFragmentSelector"))
+    GetDASHStreamingSessionURLInput.add_member(:expires, Shapes::ShapeRef.new(shape: Expires, location_name: "Expires"))
+    GetDASHStreamingSessionURLInput.add_member(:max_manifest_fragment_results, Shapes::ShapeRef.new(shape: PageLimit, location_name: "MaxManifestFragmentResults"))
+    GetDASHStreamingSessionURLInput.struct_class = Types::GetDASHStreamingSessionURLInput
+
+    GetDASHStreamingSessionURLOutput.add_member(:dash_streaming_session_url, Shapes::ShapeRef.new(shape: DASHStreamingSessionURL, location_name: "DASHStreamingSessionURL"))
+    GetDASHStreamingSessionURLOutput.struct_class = Types::GetDASHStreamingSessionURLOutput
+
     GetHLSStreamingSessionURLInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
     GetHLSStreamingSessionURLInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: ResourceARN, location_name: "StreamARN"))
-    GetHLSStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: PlaybackMode, location_name: "PlaybackMode"))
+    GetHLSStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: HLSPlaybackMode, location_name: "PlaybackMode"))
     GetHLSStreamingSessionURLInput.add_member(:hls_fragment_selector, Shapes::ShapeRef.new(shape: HLSFragmentSelector, location_name: "HLSFragmentSelector"))
     GetHLSStreamingSessionURLInput.add_member(:container_format, Shapes::ShapeRef.new(shape: ContainerFormat, location_name: "ContainerFormat"))
-    GetHLSStreamingSessionURLInput.add_member(:discontinuity_mode, Shapes::ShapeRef.new(shape: DiscontinuityMode, location_name: "DiscontinuityMode"))
-    GetHLSStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: DisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
+    GetHLSStreamingSessionURLInput.add_member(:discontinuity_mode, Shapes::ShapeRef.new(shape: HLSDiscontinuityMode, location_name: "DiscontinuityMode"))
+    GetHLSStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: HLSDisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
     GetHLSStreamingSessionURLInput.add_member(:expires, Shapes::ShapeRef.new(shape: Expires, location_name: "Expires"))
     GetHLSStreamingSessionURLInput.add_member(:max_media_playlist_fragment_results, Shapes::ShapeRef.new(shape: PageLimit, location_name: "MaxMediaPlaylistFragmentResults"))
     GetHLSStreamingSessionURLInput.struct_class = Types::GetHLSStreamingSessionURLInput
@@ -153,6 +183,22 @@ module Aws::KinesisVideoArchivedMedia
         "uid" => "kinesis-video-archived-media-2017-09-30",
       }
 
+      api.add_operation(:get_dash_streaming_session_url, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "GetDASHStreamingSessionURL"
+        o.http_method = "POST"
+        o.http_request_uri = "/getDASHStreamingSessionURL"
+        o.input = Shapes::ShapeRef.new(shape: GetDASHStreamingSessionURLInput)
+        o.output = Shapes::ShapeRef.new(shape: GetDASHStreamingSessionURLOutput)
+        o.errors << Shapes::ShapeRef.new(shape: ResourceNotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+        o.errors << Shapes::ShapeRef.new(shape: ClientLimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: NotAuthorizedException)
+        o.errors << Shapes::ShapeRef.new(shape: UnsupportedStreamMediaTypeException)
+        o.errors << Shapes::ShapeRef.new(shape: NoDataRetentionException)
+        o.errors << Shapes::ShapeRef.new(shape: MissingCodecPrivateDataException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidCodecPrivateDataException)
+      end)
+
       api.add_operation(:get_hls_streaming_session_url, Seahorse::Model::Operation.new.tap do |o|
         o.name = "GetHLSStreamingSessionURL"
         o.http_method = "POST"
@@ -191,6 +237,12 @@ module Aws::KinesisVideoArchivedMedia
         o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
         o.errors << Shapes::ShapeRef.new(shape: ClientLimitExceededException)
         o.errors << Shapes::ShapeRef.new(shape: NotAuthorizedException)
+        o[:pager] = Aws::Pager.new(
+          limit_key: "max_results",
+          tokens: {
+            "next_token" => "next_token"
+          }
+        )
       end)
     end
 

data/lib/aws-sdk-kinesisvideoarchivedmedia/errors.rb

@@ -6,6 +6,36 @@
 # WARNING ABOUT GENERATED CODE
 
 module Aws::KinesisVideoArchivedMedia
+
+  # When KinesisVideoArchivedMedia returns an error response, the Ruby SDK constructs and raises an error.
+  # These errors all extend Aws::KinesisVideoArchivedMedia::Errors::ServiceError < {Aws::Errors::ServiceError}
+  #
+  # You can rescue all KinesisVideoArchivedMedia errors using ServiceError:
+  #
+  #     begin
+  #       # do stuff
+  #     rescue Aws::KinesisVideoArchivedMedia::Errors::ServiceError
+  #       # rescues all KinesisVideoArchivedMedia API errors
+  #     end
+  #
+  #
+  # ## Request Context
+  # ServiceError objects have a {Aws::Errors::ServiceError#context #context} method that returns
+  # information about the request that generated the error.
+  # See {Seahorse::Client::RequestContext} for more information.
+  #
+  # ## Error Classes
+  # * {ClientLimitExceededException}
+  # * {InvalidArgumentException}
+  # * {InvalidCodecPrivateDataException}
+  # * {MissingCodecPrivateDataException}
+  # * {NoDataRetentionException}
+  # * {NotAuthorizedException}
+  # * {ResourceNotFoundException}
+  # * {UnsupportedStreamMediaTypeException}
+  #
+  # Additionally, error classes are dynamically generated for service errors based on the error code
+  # if they are not defined above.
   module Errors
 
     extend Aws::Errors::DynamicErrors
@@ -23,7 +53,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class InvalidArgumentException < ServiceError
@@ -39,7 +68,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class InvalidCodecPrivateDataException < ServiceError
@@ -55,7 +83,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class MissingCodecPrivateDataException < ServiceError
@@ -71,7 +98,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class NoDataRetentionException < ServiceError
@@ -87,7 +113,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class NotAuthorizedException < ServiceError
@@ -103,7 +128,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class ResourceNotFoundException < ServiceError
@@ -119,7 +143,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
     class UnsupportedStreamMediaTypeException < ServiceError
@@ -135,7 +158,6 @@ module Aws::KinesisVideoArchivedMedia
       def message
         @message || @data[:message]
       end
-
     end
 
   end

data/lib/aws-sdk-kinesisvideoarchivedmedia/resource.rb

@@ -6,6 +6,13 @@
 # WARNING ABOUT GENERATED CODE
 
 module Aws::KinesisVideoArchivedMedia
+  # This class provides a resource oriented interface for KinesisVideoArchivedMedia.
+  # To create a resource object:
+  #     resource = Aws::KinesisVideoArchivedMedia::Resource.new(region: 'us-west-2')
+  # You can supply a client object with custom configuration that will be used for all resource operations.
+  # If you do not pass +:client+, a default client will be constructed.
+  #     client = Aws::KinesisVideoArchivedMedia::Client.new(region: 'us-west-2')
+  #     resource = Aws::KinesisVideoArchivedMedia::Resource.new(client: client)
   class Resource
 
     # @param options ({})

data/lib/aws-sdk-kinesisvideoarchivedmedia/types.rb

@@ -21,10 +21,133 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
+    # Contains the range of timestamps for the requested media, and the
+    # source of the timestamps.
+    #
+    # @note When making an API call, you may pass DASHFragmentSelector
+    #   data as a hash:
+    #
+    #       {
+    #         fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #         timestamp_range: {
+    #           start_timestamp: Time.now,
+    #           end_timestamp: Time.now,
+    #         },
+    #       }
+    #
+    # @!attribute [rw] fragment_selector_type
+    #   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`.
+    #   @return [String]
+    #
+    # @!attribute [rw] timestamp_range
+    #   The start and end of the timestamp range for the requested media.
+    #
+    #   This value should not be present if `PlaybackType` is `LIVE`.
+    #   @return [Types::DASHTimestampRange]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/DASHFragmentSelector AWS API Documentation
+    #
+    class DASHFragmentSelector < Struct.new(
+      :fragment_selector_type,
+      :timestamp_range)
+      include Aws::Structure
+    end
+
+    # The start and end of the timestamp range for the requested media.
+    #
+    # This value should not be present if `PlaybackType` is `LIVE`.
+    #
+    # <note markdown="1"> The values in the `DASHimestampRange` are inclusive. Fragments that
+    # begin before the start time but continue past it, or fragments that
+    # begin before the end time but continue past it, are included in the
+    # session.
+    #
+    #  </note>
+    #
+    # @note When making an API call, you may pass DASHTimestampRange
+    #   data as a hash:
+    #
+    #       {
+    #         start_timestamp: Time.now,
+    #         end_timestamp: Time.now,
+    #       }
+    #
+    # @!attribute [rw] start_timestamp
+    #   The start of the timestamp range for the requested media.
+    #
+    #   If the `DASHTimestampRange` value is specified, the `StartTimestamp`
+    #   value is required.
+    #
+    #   <note markdown="1"> 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.
+    #
+    #    </note>
+    #   @return [Time]
+    #
+    # @!attribute [rw] end_timestamp
+    #   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.
+    #
+    #   <note markdown="1"> 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.
+    #
+    #    </note>
+    #   @return [Time]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/DASHTimestampRange AWS API Documentation
+    #
+    class DASHTimestampRange < Struct.new(
+      :start_timestamp,
+      :end_timestamp)
+      include Aws::Structure
+    end
+
     # Represents a segment of video or other time-delimited data.
     #
     # @!attribute [rw] fragment_number
-    #   The index value of the fragment.
+    #   The unique identifier of the fragment. This value monotonically
+    #   increases based on the ingestion order.
     #   @return [String]
     #
     # @!attribute [rw] fragment_size_in_bytes
@@ -103,13 +226,214 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
+    # @note When making an API call, you may pass GetDASHStreamingSessionURLInput
+    #   data as a hash:
+    #
+    #       {
+    #         stream_name: "StreamName",
+    #         stream_arn: "ResourceARN",
+    #         playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
+    #         display_fragment_timestamp: "ALWAYS", # accepts ALWAYS, NEVER
+    #         display_fragment_number: "ALWAYS", # accepts ALWAYS, NEVER
+    #         dash_fragment_selector: {
+    #           fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #           timestamp_range: {
+    #             start_timestamp: Time.now,
+    #             end_timestamp: Time.now,
+    #           },
+    #         },
+    #         expires: 1,
+    #         max_manifest_fragment_results: 1,
+    #       }
+    #
+    # @!attribute [rw] stream_name
+    #   The name of the stream for which to retrieve the MPEG-DASH manifest
+    #   URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #   @return [String]
+    #
+    # @!attribute [rw] stream_arn
+    #   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`.
+    #   @return [String]
+    #
+    # @!attribute [rw] playback_mode
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
+    #
+    #   Features of the three types of sessions include the following:
+    #
+    #   * <b> <code>LIVE</code> </b>\: 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.
+    #
+    #     <note markdown="1"> 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.
+    #
+    #      </note>
+    #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: 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.
+    #
+    #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest contains all the fragments for the session, up
+    #     to the number that is specified in
+    #     `MaxMediaPlaylistFragmentResults`. 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`.
+    #   @return [String]
+    #
+    # @!attribute [rw] display_fragment_timestamp
+    #   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.
+    #   @return [String]
+    #
+    # @!attribute [rw] display_fragment_number
+    #   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`.
+    #   @return [String]
+    #
+    # @!attribute [rw] dash_fragment_selector
+    #   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.</p>
+    #   `
+    #   @return [Types::DASHFragmentSelector]
+    #
+    # @!attribute [rw] 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).
+    #   @return [Integer]
+    #
+    # @!attribute [rw] max_manifest_fragment_results
+    #   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.
+    #   @return [Integer]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetDASHStreamingSessionURLInput AWS API Documentation
+    #
+    class GetDASHStreamingSessionURLInput < Struct.new(
+      :stream_name,
+      :stream_arn,
+      :playback_mode,
+      :display_fragment_timestamp,
+      :display_fragment_number,
+      :dash_fragment_selector,
+      :expires,
+      :max_manifest_fragment_results)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] dash_streaming_session_url
+    #   The URL (containing the session token) that a media player can use
+    #   to retrieve the MPEG-DASH manifest.
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetDASHStreamingSessionURLOutput AWS API Documentation
+    #
+    class GetDASHStreamingSessionURLOutput < Struct.new(
+      :dash_streaming_session_url)
+      include Aws::Structure
+    end
+
     # @note When making an API call, you may pass GetHLSStreamingSessionURLInput
     #   data as a hash:
     #
     #       {
     #         stream_name: "StreamName",
     #         stream_arn: "ResourceARN",
-    #         playback_mode: "LIVE", # accepts LIVE, ON_DEMAND
+    #         playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
     #         hls_fragment_selector: {
     #           fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
     #           timestamp_range: {
@@ -118,7 +442,7 @@ module Aws::KinesisVideoArchivedMedia
     #           },
     #         },
     #         container_format: "FRAGMENTED_MP4", # accepts FRAGMENTED_MP4, MPEG_TS
-    #         discontinuity_mode: "ALWAYS", # accepts ALWAYS, NEVER
+    #         discontinuity_mode: "ALWAYS", # accepts ALWAYS, NEVER, ON_DISCONTINUITY
     #         display_fragment_timestamp: "ALWAYS", # accepts ALWAYS, NEVER
     #         expires: 1,
     #         max_media_playlist_fragment_results: 1,
@@ -139,9 +463,9 @@ module Aws::KinesisVideoArchivedMedia
     #   @return [String]
     #
     # @!attribute [rw] playback_mode
-    #   Whether to retrieve live or archived, on-demand data.
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
     #
-    #   Features of the two types of session include the following:
+    #   Features of the three types of sessions include the following:
     #
     #   * <b> <code>LIVE</code> </b>\: For sessions of this type, the HLS
     #     media playlist is continually updated with the latest fragments as
@@ -163,6 +487,20 @@ module Aws::KinesisVideoArchivedMedia
     #
     #      </note>
     #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: For sessions of this type, the
+    #     HLS media playlist 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 media playlist
+    #     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.
+    #
     #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the
     #     HLS media playlist contains all the fragments for the session, up
     #     to the number that is specified in
@@ -172,7 +510,7 @@ module Aws::KinesisVideoArchivedMedia
     #     control for choosing the position in the playback window to
     #     display.
     #
-    #   In both playback modes, if `FragmentSelectorType` is
+    #   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 HLS media
@@ -185,15 +523,16 @@ module Aws::KinesisVideoArchivedMedia
     #   @return [String]
     #
     # @!attribute [rw] hls_fragment_selector
-    #   The time range of the requested fragment, and the source of the
+    #   The time range of the requested fragment and the source of the
     #   timestamps.
     #
-    #   This parameter is required if `PlaybackMode` is `ON_DEMAND`. 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`, both `FragmentSelectorType` and `TimestampRange` must
-    #   be set.
+    #   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.</p>
+    #   `
     #   @return [Types::HLSFragmentSelector]
     #
     # @!attribute [rw] container_format
@@ -211,24 +550,40 @@ module Aws::KinesisVideoArchivedMedia
     #   @return [String]
     #
     # @!attribute [rw] discontinuity_mode
-    #   Specifies when flags marking discontinuities between fragments will
-    #   be added to the media playlists. The default is `ALWAYS` when
-    #   HLSFragmentSelector is `SERVER_TIMESTAMP`, and `NEVER` when it is
-    #   `PRODUCER_TIMESTAMP`.
+    #   Specifies when flags marking discontinuities between fragments are
+    #   added to the media playlists.
     #
     #   Media players typically build a timeline of media content to play,
     #   based on the timestamps of each fragment. This means that if there
-    #   is any overlap between fragments (as is typical if
-    #   HLSFragmentSelector is `SERVER_TIMESTAMP`), the media player
-    #   timeline has small gaps between fragments in some places, and
-    #   overwrites frames in other places. When there are discontinuity
-    #   flags between fragments, the media player is expected to reset the
-    #   timeline, resulting in the fragment being played immediately after
-    #   the previous fragment. We recommend that you always have
-    #   discontinuity flags between fragments if the fragment timestamps are
-    #   not accurate or if fragments might be missing. You should not place
-    #   discontinuity flags between fragments for the player timeline to
-    #   accurately map to the producer timestamps.
+    #   is any overlap or gap between fragments (as is typical if
+    #   HLSFragmentSelector is set to `SERVER_TIMESTAMP`), the media player
+    #   timeline will also have small gaps between fragments in some places,
+    #   and will overwrite frames in other places. Gaps in the media player
+    #   timeline can cause playback to stall and overlaps can cause playback
+    #   to be jittery. When there are discontinuity flags between fragments,
+    #   the media player is expected to reset the timeline, resulting in the
+    #   next fragment being played immediately after the previous fragment.
+    #
+    #   The following modes are supported:
+    #
+    #   * `ALWAYS`\: a discontinuity marker is placed between every fragment
+    #     in the HLS media playlist. It is recommended to use a value of
+    #     `ALWAYS` if the fragment timestamps are not accurate.
+    #
+    #   * `NEVER`\: no discontinuity markers are placed anywhere. It is
+    #     recommended to use a value of `NEVER` to ensure the media player
+    #     timeline most accurately maps to the producer timestamps.
+    #
+    #   * `ON_DISCONTIUNITY`\: a discontinuity marker is placed between
+    #     fragments that have a gap or overlap of more than 50 milliseconds.
+    #     For most playback scenarios, it is recommended to use a value of
+    #     `ON_DISCONTINUITY` so that the media player timeline is only reset
+    #     when there is a significant issue with the media timeline (e.g. a
+    #     missing fragment).
+    #
+    #   The default is `ALWAYS` when HLSFragmentSelector is set to
+    #   `SERVER_TIMESTAMP`, and `NEVER` when it is set to
+    #   `PRODUCER_TIMESTAMP`.
     #   @return [String]
     #
     # @!attribute [rw] display_fragment_timestamp
@@ -253,8 +608,8 @@ module Aws::KinesisVideoArchivedMedia
     #   can be between 300 (5 minutes) and 43200 (12 hours).
     #
     #   When a session expires, no new calls to `GetHLSMasterPlaylist`,
-    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, or
-    #   `GetMP4MediaFragment` can be made for that session.
+    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, `GetMP4MediaFragment`,
+    #   or `GetTSFragment` can be made for that session.
     #
     #   The default is 300 (5 minutes).
     #   @return [Integer]
@@ -274,8 +629,8 @@ module Aws::KinesisVideoArchivedMedia
     #   playback. We recommend that a live HLS media playlist have a minimum
     #   of 3 fragments and a maximum of 10 fragments.
     #
-    #   The default is 5 fragments if `PlaybackMode` is `LIVE`, and 1,000 if
-    #   `PlaybackMode` is `ON_DEMAND`.
+    #   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
@@ -396,12 +751,12 @@ module Aws::KinesisVideoArchivedMedia
     #   The source of the timestamps for the requested media.
     #
     #   When `FragmentSelectorType` is set to `PRODUCER_TIMESTAMP` and
-    #   GetHLSStreamingSessionURLInput$PlaybackMode is `ON_DEMAND`, 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$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.
     #
@@ -479,8 +834,10 @@ module Aws::KinesisVideoArchivedMedia
     #   If `FragmentSelectorType` for the request is `SERVER_TIMESTAMP`,
     #   this value must be in the past.
     #
-    #   If the `HLSTimestampRange` value is specified, the `EndTimestamp`
-    #   value is required.
+    #   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.
     #
     #   <note markdown="1"> This value is inclusive. The `EndTimestamp` is compared to the
     #   (starting) timestamp of the fragment. Fragments that start before
@@ -604,8 +961,8 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
-    # A `PlaybackMode` of `ON_DEMAND` was requested for a stream that does
-    # not retain data (that is, has a `DataRetentionInHours` of 0).
+    # A streaming session was requested for a stream that does not retain
+    # data (that is, has a `DataRetentionInHours` of 0).
     #
     # @!attribute [rw] message
     #   @return [String]
@@ -633,11 +990,12 @@ module Aws::KinesisVideoArchivedMedia
     # `GetMedia` throws this error when Kinesis Video Streams can't find
     # the stream that you specified.
     #
-    # `GetHLSStreamingSessionURL` throws this error if a session with a
-    # `PlaybackMode` of `ON_DEMAND` is requested for a stream that has no
-    # fragments within the requested time range, or if a session with a
-    # `PlaybackMode` of `LIVE` is requested for a stream that has no
-    # fragments within the last 30 seconds.
+    # `GetHLSStreamingSessionURL` and `GetDASHStreamingSessionURL` throw
+    # this error if a session with a `PlaybackMode` of `ON_DEMAND` or
+    # `LIVE_REPLAY`is requested for a stream that has no fragments within
+    # the requested time range, or if a session with a `PlaybackMode` of
+    # `LIVE` is requested for a stream that has no fragments within the last
+    # 30 seconds.
     #
     # @!attribute [rw] message
     #   @return [String]
@@ -677,11 +1035,11 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
-    # The type of the media (for example, h.264 video or ACC audio) could
-    # not be determined from the codec IDs of the tracks in the first
-    # fragment for a playback session. The codec ID for track 1 should be
-    # `V_MPEG/ISO/AVC` and, optionally, the codec ID for track 2 should be
-    # `A_AAC`.
+    # The type of the media (for example, h.264 or h.265 video or ACC or
+    # G.711 audio) could not be determined from the codec IDs of the tracks
+    # in the first fragment for a playback session. The codec ID for track 1
+    # should be `V_MPEG/ISO/AVC` and, optionally, the codec ID for track 2
+    # should be `A_AAC`.
     #
     # @!attribute [rw] message
     #   @return [String]