{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.KinesisVideoArchivedMedia.GetDASHStreamingSessionURL
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves an MPEG Dynamic Adaptive Streaming over HTTP (DASH) URL for
-- the stream. You can then open the URL in a media player to view the
-- stream contents.
--
-- Both the @StreamName@ and the @StreamARN@ parameters are optional, but
-- you must specify either the @StreamName@ or the @StreamARN@ when
-- invoking this API operation.
--
-- An Amazon Kinesis video stream has the following requirements for
-- providing data through MPEG-DASH:
--
-- -   The media must contain h.264 or h.265 encoded video and, optionally,
--     AAC or G.711 encoded audio. Specifically, the codec ID of track 1
--     should be @V_MPEG\/ISO\/AVC@ (for h.264) or V_MPEGH\/ISO\/HEVC (for
--     H.265). Optionally, the codec ID of track 2 should be @A_AAC@ (for
--     AAC) or A_MS\/ACM (for G.711).
--
-- -   Data retention must be greater than 0.
--
-- -   The video track of each fragment must contain codec private data in
--     the Advanced Video Coding (AVC) for H.264 format and HEVC for H.265
--     format. For more information, see
--     <https://www.iso.org/standard/55980.html MPEG-4 specification ISO\/IEC 14496-15>.
--     For information about adapting stream data to a given format, see
--     <http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-reference-nal.html NAL Adaptation Flags>.
--
-- -   The audio track (if present) of each fragment must contain codec
--     private data in the AAC format
--     (<https://www.iso.org/standard/43345.html AAC specification ISO\/IEC 13818-7>)
--     or the
--     <http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html MS Wave format>.
--
-- The following procedure shows how to use MPEG-DASH with Kinesis Video
-- Streams:
--
-- 1.  Get an endpoint using
--     <http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_GetDataEndpoint.html GetDataEndpoint>,
--     specifying @GET_DASH_STREAMING_SESSION_URL@ for the @APIName@
--     parameter.
--
-- 2.  Retrieve the MPEG-DASH URL using @GetDASHStreamingSessionURL@.
--     Kinesis Video Streams creates an MPEG-DASH streaming session to be
--     used for accessing content in a stream using the MPEG-DASH protocol.
--     @GetDASHStreamingSessionURL@ returns an authenticated URL (that
--     includes an encrypted session token) for the session\'s MPEG-DASH
--     /manifest/ (the root resource needed for streaming with MPEG-DASH).
--
--     Don\'t share or store this token where an unauthorized entity can
--     access it. The token provides access to the content of the stream.
--     Safeguard the token with the same measures that you use with your
--     AWS credentials.
--
--     The media that is made available through the manifest consists only
--     of the requested stream, time range, and format. No other media data
--     (such as frames outside the requested window or alternate bitrates)
--     is made available.
--
-- 3.  Provide the URL (containing the encrypted session token) for the
--     MPEG-DASH manifest to a media player that supports the MPEG-DASH
--     protocol. Kinesis Video Streams makes the initialization fragment
--     and media fragments available through the manifest URL. The
--     initialization fragment contains the codec private data for the
--     stream, and other data needed to set up the video or audio decoder
--     and renderer. The media fragments contain encoded video frames or
--     encoded audio samples.
--
-- 4.  The media player receives the authenticated URL and requests stream
--     metadata and media data normally. When the media player requests
--     data, it calls the following actions:
--
--     -   __GetDASHManifest:__ Retrieves an MPEG DASH manifest, which
--         contains the metadata for the media that you want to playback.
--
--     -   __GetMP4InitFragment:__ Retrieves the MP4 initialization
--         fragment. The media player typically loads the initialization
--         fragment before loading any media fragments. This fragment
--         contains the \"@fytp@\" and \"@moov@\" MP4 atoms, and the child
--         atoms that are needed to initialize the media player decoder.
--
--         The initialization fragment does not correspond to a fragment in
--         a Kinesis video stream. It contains only the codec private data
--         for the stream and respective track, which the media player
--         needs to decode the media frames.
--
--     -   __GetMP4MediaFragment:__ Retrieves MP4 media fragments. These
--         fragments contain the \"@moof@\" and \"@mdat@\" MP4 atoms and
--         their child atoms, containing the encoded fragment\'s media
--         frames and their timestamps.
--
--         After the first media fragment is made available in a streaming
--         session, any fragments that don\'t contain the same codec
--         private data cause an error to be returned when those different
--         media fragments are loaded. Therefore, the codec private data
--         should not change between fragments in a session. This also
--         means that the session fails if the fragments in a stream change
--         from having only video to having both audio and video.
--
--         Data retrieved with this action is billable. See
--         <https://aws.amazon.com/kinesis/video-streams/pricing/ Pricing>
--         for details.
--
-- For restrictions that apply to MPEG-DASH sessions, see
-- <http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/limits.html Kinesis Video Streams Limits>.
--
-- You can monitor the amount of data that the media player consumes by
-- monitoring the @GetMP4MediaFragment.OutgoingBytes@ Amazon CloudWatch
-- metric. For information about using CloudWatch to monitor Kinesis Video
-- Streams, see
-- <http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/monitoring.html Monitoring Kinesis Video Streams>.
-- For pricing information, see
-- <https://aws.amazon.com/kinesis/video-streams/pricing/ Amazon Kinesis Video Streams Pricing>
-- and <https://aws.amazon.com/pricing/ AWS Pricing>. Charges for both HLS
-- sessions and outgoing AWS data apply.
--
-- For more information about HLS, see
-- <https://developer.apple.com/streaming/ HTTP Live Streaming> on the
-- <https://developer.apple.com Apple Developer site>.
--
-- If an error is thrown after invoking a Kinesis Video Streams archived
-- media API, in addition to the HTTP status code and the response body, it
-- includes the following pieces of information:
--
-- -   @x-amz-ErrorType@ HTTP header – contains a more specific error type
--     in addition to what the HTTP status code provides.
--
-- -   @x-amz-RequestId@ HTTP header – if you want to report an issue to
--     AWS, the support team can better diagnose the problem if given the
--     Request Id.
--
-- Both the HTTP status code and the ErrorType header can be utilized to
-- make programmatic decisions about whether errors are retry-able and
-- under what conditions, as well as provide information on what actions
-- the client programmer might need to take in order to successfully try
-- again.
--
-- For more information, see the __Errors__ section at the bottom of this
-- topic, as well as
-- <https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/CommonErrors.html Common Errors>.
module Amazonka.KinesisVideoArchivedMedia.GetDASHStreamingSessionURL
  ( -- * Creating a Request
    GetDASHStreamingSessionURL (..),
    newGetDASHStreamingSessionURL,

    -- * Request Lenses
    getDASHStreamingSessionURL_displayFragmentTimestamp,
    getDASHStreamingSessionURL_expires,
    getDASHStreamingSessionURL_dASHFragmentSelector,
    getDASHStreamingSessionURL_maxManifestFragmentResults,
    getDASHStreamingSessionURL_streamARN,
    getDASHStreamingSessionURL_playbackMode,
    getDASHStreamingSessionURL_streamName,
    getDASHStreamingSessionURL_displayFragmentNumber,

    -- * Destructuring the Response
    GetDASHStreamingSessionURLResponse (..),
    newGetDASHStreamingSessionURLResponse,

    -- * Response Lenses
    getDASHStreamingSessionURLResponse_dASHStreamingSessionURL,
    getDASHStreamingSessionURLResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.KinesisVideoArchivedMedia.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newGetDASHStreamingSessionURL' smart constructor.
data GetDASHStreamingSessionURL = GetDASHStreamingSessionURL'
  { -- | 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.
    GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp :: Prelude.Maybe DASHDisplayFragmentTimestamp,
    -- | 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).
    GetDASHStreamingSessionURL -> Maybe Natural
expires :: Prelude.Maybe Prelude.Natural,
    -- | 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.
    GetDASHStreamingSessionURL -> Maybe DASHFragmentSelector
dASHFragmentSelector :: Prelude.Maybe DASHFragmentSelector,
    -- | 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.
    GetDASHStreamingSessionURL -> Maybe Natural
maxManifestFragmentResults :: Prelude.Maybe Prelude.Natural,
    -- | 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@.
    GetDASHStreamingSessionURL -> Maybe Text
streamARN :: Prelude.Maybe Prelude.Text,
    -- | 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@.
    GetDASHStreamingSessionURL -> Maybe DASHPlaybackMode
playbackMode :: Prelude.Maybe DASHPlaybackMode,
    -- | The name of the stream for which to retrieve the MPEG-DASH manifest URL.
    --
    -- You must specify either the @StreamName@ or the @StreamARN@.
    GetDASHStreamingSessionURL -> Maybe Text
streamName :: Prelude.Maybe Prelude.Text,
    -- | 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@.
    GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentNumber
displayFragmentNumber :: Prelude.Maybe DASHDisplayFragmentNumber
  }
  deriving (GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool
(GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool)
-> (GetDASHStreamingSessionURL
    -> GetDASHStreamingSessionURL -> Bool)
-> Eq GetDASHStreamingSessionURL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool
$c/= :: GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool
== :: GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool
$c== :: GetDASHStreamingSessionURL -> GetDASHStreamingSessionURL -> Bool
Prelude.Eq, ReadPrec [GetDASHStreamingSessionURL]
ReadPrec GetDASHStreamingSessionURL
Int -> ReadS GetDASHStreamingSessionURL
ReadS [GetDASHStreamingSessionURL]
(Int -> ReadS GetDASHStreamingSessionURL)
-> ReadS [GetDASHStreamingSessionURL]
-> ReadPrec GetDASHStreamingSessionURL
-> ReadPrec [GetDASHStreamingSessionURL]
-> Read GetDASHStreamingSessionURL
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetDASHStreamingSessionURL]
$creadListPrec :: ReadPrec [GetDASHStreamingSessionURL]
readPrec :: ReadPrec GetDASHStreamingSessionURL
$creadPrec :: ReadPrec GetDASHStreamingSessionURL
readList :: ReadS [GetDASHStreamingSessionURL]
$creadList :: ReadS [GetDASHStreamingSessionURL]
readsPrec :: Int -> ReadS GetDASHStreamingSessionURL
$creadsPrec :: Int -> ReadS GetDASHStreamingSessionURL
Prelude.Read, Int -> GetDASHStreamingSessionURL -> ShowS
[GetDASHStreamingSessionURL] -> ShowS
GetDASHStreamingSessionURL -> String
(Int -> GetDASHStreamingSessionURL -> ShowS)
-> (GetDASHStreamingSessionURL -> String)
-> ([GetDASHStreamingSessionURL] -> ShowS)
-> Show GetDASHStreamingSessionURL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetDASHStreamingSessionURL] -> ShowS
$cshowList :: [GetDASHStreamingSessionURL] -> ShowS
show :: GetDASHStreamingSessionURL -> String
$cshow :: GetDASHStreamingSessionURL -> String
showsPrec :: Int -> GetDASHStreamingSessionURL -> ShowS
$cshowsPrec :: Int -> GetDASHStreamingSessionURL -> ShowS
Prelude.Show, (forall x.
 GetDASHStreamingSessionURL -> Rep GetDASHStreamingSessionURL x)
-> (forall x.
    Rep GetDASHStreamingSessionURL x -> GetDASHStreamingSessionURL)
-> Generic GetDASHStreamingSessionURL
forall x.
Rep GetDASHStreamingSessionURL x -> GetDASHStreamingSessionURL
forall x.
GetDASHStreamingSessionURL -> Rep GetDASHStreamingSessionURL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetDASHStreamingSessionURL x -> GetDASHStreamingSessionURL
$cfrom :: forall x.
GetDASHStreamingSessionURL -> Rep GetDASHStreamingSessionURL x
Prelude.Generic)

-- |
-- Create a value of 'GetDASHStreamingSessionURL' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'displayFragmentTimestamp', 'getDASHStreamingSessionURL_displayFragmentTimestamp' - 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.
--
-- 'expires', 'getDASHStreamingSessionURL_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).
--
-- 'dASHFragmentSelector', 'getDASHStreamingSessionURL_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.
--
-- 'maxManifestFragmentResults', 'getDASHStreamingSessionURL_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.
--
-- 'streamARN', 'getDASHStreamingSessionURL_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@.
--
-- 'playbackMode', 'getDASHStreamingSessionURL_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.
--
-- 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@.
--
-- 'streamName', 'getDASHStreamingSessionURL_streamName' - The name of the stream for which to retrieve the MPEG-DASH manifest URL.
--
-- You must specify either the @StreamName@ or the @StreamARN@.
--
-- 'displayFragmentNumber', 'getDASHStreamingSessionURL_displayFragmentNumber' - 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@.
newGetDASHStreamingSessionURL ::
  GetDASHStreamingSessionURL
newGetDASHStreamingSessionURL :: GetDASHStreamingSessionURL
newGetDASHStreamingSessionURL =
  GetDASHStreamingSessionURL' :: Maybe DASHDisplayFragmentTimestamp
-> Maybe Natural
-> Maybe DASHFragmentSelector
-> Maybe Natural
-> Maybe Text
-> Maybe DASHPlaybackMode
-> Maybe Text
-> Maybe DASHDisplayFragmentNumber
-> GetDASHStreamingSessionURL
GetDASHStreamingSessionURL'
    { $sel:displayFragmentTimestamp:GetDASHStreamingSessionURL' :: Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp =
        Maybe DASHDisplayFragmentTimestamp
forall a. Maybe a
Prelude.Nothing,
      $sel:expires:GetDASHStreamingSessionURL' :: Maybe Natural
expires = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:dASHFragmentSelector:GetDASHStreamingSessionURL' :: Maybe DASHFragmentSelector
dASHFragmentSelector = Maybe DASHFragmentSelector
forall a. Maybe a
Prelude.Nothing,
      $sel:maxManifestFragmentResults:GetDASHStreamingSessionURL' :: Maybe Natural
maxManifestFragmentResults = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:streamARN:GetDASHStreamingSessionURL' :: Maybe Text
streamARN = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:playbackMode:GetDASHStreamingSessionURL' :: Maybe DASHPlaybackMode
playbackMode = Maybe DASHPlaybackMode
forall a. Maybe a
Prelude.Nothing,
      $sel:streamName:GetDASHStreamingSessionURL' :: Maybe Text
streamName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:displayFragmentNumber:GetDASHStreamingSessionURL' :: Maybe DASHDisplayFragmentNumber
displayFragmentNumber = Maybe DASHDisplayFragmentNumber
forall a. Maybe a
Prelude.Nothing
    }

-- | 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.
getDASHStreamingSessionURL_displayFragmentTimestamp :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe DASHDisplayFragmentTimestamp)
getDASHStreamingSessionURL_displayFragmentTimestamp :: (Maybe DASHDisplayFragmentTimestamp
 -> f (Maybe DASHDisplayFragmentTimestamp))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_displayFragmentTimestamp = (GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentTimestamp)
-> (GetDASHStreamingSessionURL
    -> Maybe DASHDisplayFragmentTimestamp
    -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe DASHDisplayFragmentTimestamp)
     (Maybe DASHDisplayFragmentTimestamp)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp :: Maybe DASHDisplayFragmentTimestamp
$sel:displayFragmentTimestamp:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp} -> Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe DASHDisplayFragmentTimestamp
a -> GetDASHStreamingSessionURL
s {$sel:displayFragmentTimestamp:GetDASHStreamingSessionURL' :: Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp = Maybe DASHDisplayFragmentTimestamp
a} :: GetDASHStreamingSessionURL)

-- | 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).
getDASHStreamingSessionURL_expires :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe Prelude.Natural)
getDASHStreamingSessionURL_expires :: (Maybe Natural -> f (Maybe Natural))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_expires = (GetDASHStreamingSessionURL -> Maybe Natural)
-> (GetDASHStreamingSessionURL
    -> Maybe Natural -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe Natural
expires :: Maybe Natural
$sel:expires:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Natural
expires} -> Maybe Natural
expires) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe Natural
a -> GetDASHStreamingSessionURL
s {$sel:expires:GetDASHStreamingSessionURL' :: Maybe Natural
expires = Maybe Natural
a} :: GetDASHStreamingSessionURL)

-- | 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.
getDASHStreamingSessionURL_dASHFragmentSelector :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe DASHFragmentSelector)
getDASHStreamingSessionURL_dASHFragmentSelector :: (Maybe DASHFragmentSelector -> f (Maybe DASHFragmentSelector))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_dASHFragmentSelector = (GetDASHStreamingSessionURL -> Maybe DASHFragmentSelector)
-> (GetDASHStreamingSessionURL
    -> Maybe DASHFragmentSelector -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe DASHFragmentSelector)
     (Maybe DASHFragmentSelector)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe DASHFragmentSelector
dASHFragmentSelector :: Maybe DASHFragmentSelector
$sel:dASHFragmentSelector:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHFragmentSelector
dASHFragmentSelector} -> Maybe DASHFragmentSelector
dASHFragmentSelector) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe DASHFragmentSelector
a -> GetDASHStreamingSessionURL
s {$sel:dASHFragmentSelector:GetDASHStreamingSessionURL' :: Maybe DASHFragmentSelector
dASHFragmentSelector = Maybe DASHFragmentSelector
a} :: GetDASHStreamingSessionURL)

-- | 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.
getDASHStreamingSessionURL_maxManifestFragmentResults :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe Prelude.Natural)
getDASHStreamingSessionURL_maxManifestFragmentResults :: (Maybe Natural -> f (Maybe Natural))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_maxManifestFragmentResults = (GetDASHStreamingSessionURL -> Maybe Natural)
-> (GetDASHStreamingSessionURL
    -> Maybe Natural -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe Natural
maxManifestFragmentResults :: Maybe Natural
$sel:maxManifestFragmentResults:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Natural
maxManifestFragmentResults} -> Maybe Natural
maxManifestFragmentResults) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe Natural
a -> GetDASHStreamingSessionURL
s {$sel:maxManifestFragmentResults:GetDASHStreamingSessionURL' :: Maybe Natural
maxManifestFragmentResults = Maybe Natural
a} :: GetDASHStreamingSessionURL)

-- | 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@.
getDASHStreamingSessionURL_streamARN :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe Prelude.Text)
getDASHStreamingSessionURL_streamARN :: (Maybe Text -> f (Maybe Text))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_streamARN = (GetDASHStreamingSessionURL -> Maybe Text)
-> (GetDASHStreamingSessionURL
    -> Maybe Text -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe Text
streamARN :: Maybe Text
$sel:streamARN:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Text
streamARN} -> Maybe Text
streamARN) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe Text
a -> GetDASHStreamingSessionURL
s {$sel:streamARN:GetDASHStreamingSessionURL' :: Maybe Text
streamARN = Maybe Text
a} :: GetDASHStreamingSessionURL)

-- | 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@.
getDASHStreamingSessionURL_playbackMode :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe DASHPlaybackMode)
getDASHStreamingSessionURL_playbackMode :: (Maybe DASHPlaybackMode -> f (Maybe DASHPlaybackMode))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_playbackMode = (GetDASHStreamingSessionURL -> Maybe DASHPlaybackMode)
-> (GetDASHStreamingSessionURL
    -> Maybe DASHPlaybackMode -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe DASHPlaybackMode)
     (Maybe DASHPlaybackMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe DASHPlaybackMode
playbackMode :: Maybe DASHPlaybackMode
$sel:playbackMode:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHPlaybackMode
playbackMode} -> Maybe DASHPlaybackMode
playbackMode) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe DASHPlaybackMode
a -> GetDASHStreamingSessionURL
s {$sel:playbackMode:GetDASHStreamingSessionURL' :: Maybe DASHPlaybackMode
playbackMode = Maybe DASHPlaybackMode
a} :: GetDASHStreamingSessionURL)

-- | The name of the stream for which to retrieve the MPEG-DASH manifest URL.
--
-- You must specify either the @StreamName@ or the @StreamARN@.
getDASHStreamingSessionURL_streamName :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe Prelude.Text)
getDASHStreamingSessionURL_streamName :: (Maybe Text -> f (Maybe Text))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_streamName = (GetDASHStreamingSessionURL -> Maybe Text)
-> (GetDASHStreamingSessionURL
    -> Maybe Text -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe Text
streamName :: Maybe Text
$sel:streamName:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Text
streamName} -> Maybe Text
streamName) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe Text
a -> GetDASHStreamingSessionURL
s {$sel:streamName:GetDASHStreamingSessionURL' :: Maybe Text
streamName = Maybe Text
a} :: GetDASHStreamingSessionURL)

-- | 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@.
getDASHStreamingSessionURL_displayFragmentNumber :: Lens.Lens' GetDASHStreamingSessionURL (Prelude.Maybe DASHDisplayFragmentNumber)
getDASHStreamingSessionURL_displayFragmentNumber :: (Maybe DASHDisplayFragmentNumber
 -> f (Maybe DASHDisplayFragmentNumber))
-> GetDASHStreamingSessionURL -> f GetDASHStreamingSessionURL
getDASHStreamingSessionURL_displayFragmentNumber = (GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentNumber)
-> (GetDASHStreamingSessionURL
    -> Maybe DASHDisplayFragmentNumber -> GetDASHStreamingSessionURL)
-> Lens
     GetDASHStreamingSessionURL
     GetDASHStreamingSessionURL
     (Maybe DASHDisplayFragmentNumber)
     (Maybe DASHDisplayFragmentNumber)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURL' {Maybe DASHDisplayFragmentNumber
displayFragmentNumber :: Maybe DASHDisplayFragmentNumber
$sel:displayFragmentNumber:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentNumber
displayFragmentNumber} -> Maybe DASHDisplayFragmentNumber
displayFragmentNumber) (\s :: GetDASHStreamingSessionURL
s@GetDASHStreamingSessionURL' {} Maybe DASHDisplayFragmentNumber
a -> GetDASHStreamingSessionURL
s {$sel:displayFragmentNumber:GetDASHStreamingSessionURL' :: Maybe DASHDisplayFragmentNumber
displayFragmentNumber = Maybe DASHDisplayFragmentNumber
a} :: GetDASHStreamingSessionURL)

instance Core.AWSRequest GetDASHStreamingSessionURL where
  type
    AWSResponse GetDASHStreamingSessionURL =
      GetDASHStreamingSessionURLResponse
  request :: GetDASHStreamingSessionURL -> Request GetDASHStreamingSessionURL
request = Service
-> GetDASHStreamingSessionURL -> Request GetDASHStreamingSessionURL
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy GetDASHStreamingSessionURL
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetDASHStreamingSessionURL)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse GetDASHStreamingSessionURL))
-> Logger
-> Service
-> Proxy GetDASHStreamingSessionURL
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetDASHStreamingSessionURL)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> GetDASHStreamingSessionURLResponse
GetDASHStreamingSessionURLResponse'
            (Maybe Text -> Int -> GetDASHStreamingSessionURLResponse)
-> Either String (Maybe Text)
-> Either String (Int -> GetDASHStreamingSessionURLResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"DASHStreamingSessionURL")
            Either String (Int -> GetDASHStreamingSessionURLResponse)
-> Either String Int
-> Either String GetDASHStreamingSessionURLResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable GetDASHStreamingSessionURL

instance Prelude.NFData GetDASHStreamingSessionURL

instance Core.ToHeaders GetDASHStreamingSessionURL where
  toHeaders :: GetDASHStreamingSessionURL -> ResponseHeaders
toHeaders = ResponseHeaders -> GetDASHStreamingSessionURL -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const ResponseHeaders
forall a. Monoid a => a
Prelude.mempty

instance Core.ToJSON GetDASHStreamingSessionURL where
  toJSON :: GetDASHStreamingSessionURL -> Value
toJSON GetDASHStreamingSessionURL' {Maybe Natural
Maybe Text
Maybe DASHDisplayFragmentNumber
Maybe DASHDisplayFragmentTimestamp
Maybe DASHPlaybackMode
Maybe DASHFragmentSelector
displayFragmentNumber :: Maybe DASHDisplayFragmentNumber
streamName :: Maybe Text
playbackMode :: Maybe DASHPlaybackMode
streamARN :: Maybe Text
maxManifestFragmentResults :: Maybe Natural
dASHFragmentSelector :: Maybe DASHFragmentSelector
expires :: Maybe Natural
displayFragmentTimestamp :: Maybe DASHDisplayFragmentTimestamp
$sel:displayFragmentNumber:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentNumber
$sel:streamName:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Text
$sel:playbackMode:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHPlaybackMode
$sel:streamARN:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Text
$sel:maxManifestFragmentResults:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Natural
$sel:dASHFragmentSelector:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHFragmentSelector
$sel:expires:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe Natural
$sel:displayFragmentTimestamp:GetDASHStreamingSessionURL' :: GetDASHStreamingSessionURL -> Maybe DASHDisplayFragmentTimestamp
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"DisplayFragmentTimestamp" Text -> DASHDisplayFragmentTimestamp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (DASHDisplayFragmentTimestamp -> Pair)
-> Maybe DASHDisplayFragmentTimestamp -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DASHDisplayFragmentTimestamp
displayFragmentTimestamp,
            (Text
"Expires" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
expires,
            (Text
"DASHFragmentSelector" Text -> DASHFragmentSelector -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (DASHFragmentSelector -> Pair)
-> Maybe DASHFragmentSelector -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DASHFragmentSelector
dASHFragmentSelector,
            (Text
"MaxManifestFragmentResults" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxManifestFragmentResults,
            (Text
"StreamARN" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
streamARN,
            (Text
"PlaybackMode" Text -> DASHPlaybackMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (DASHPlaybackMode -> Pair) -> Maybe DASHPlaybackMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DASHPlaybackMode
playbackMode,
            (Text
"StreamName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
streamName,
            (Text
"DisplayFragmentNumber" Text -> DASHDisplayFragmentNumber -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (DASHDisplayFragmentNumber -> Pair)
-> Maybe DASHDisplayFragmentNumber -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DASHDisplayFragmentNumber
displayFragmentNumber
          ]
      )

instance Core.ToPath GetDASHStreamingSessionURL where
  toPath :: GetDASHStreamingSessionURL -> ByteString
toPath = ByteString -> GetDASHStreamingSessionURL -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/getDASHStreamingSessionURL"

instance Core.ToQuery GetDASHStreamingSessionURL where
  toQuery :: GetDASHStreamingSessionURL -> QueryString
toQuery = QueryString -> GetDASHStreamingSessionURL -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newGetDASHStreamingSessionURLResponse' smart constructor.
data GetDASHStreamingSessionURLResponse = GetDASHStreamingSessionURLResponse'
  { -- | The URL (containing the session token) that a media player can use to
    -- retrieve the MPEG-DASH manifest.
    GetDASHStreamingSessionURLResponse -> Maybe Text
dASHStreamingSessionURL :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetDASHStreamingSessionURLResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetDASHStreamingSessionURLResponse
-> GetDASHStreamingSessionURLResponse -> Bool
(GetDASHStreamingSessionURLResponse
 -> GetDASHStreamingSessionURLResponse -> Bool)
-> (GetDASHStreamingSessionURLResponse
    -> GetDASHStreamingSessionURLResponse -> Bool)
-> Eq GetDASHStreamingSessionURLResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetDASHStreamingSessionURLResponse
-> GetDASHStreamingSessionURLResponse -> Bool
$c/= :: GetDASHStreamingSessionURLResponse
-> GetDASHStreamingSessionURLResponse -> Bool
== :: GetDASHStreamingSessionURLResponse
-> GetDASHStreamingSessionURLResponse -> Bool
$c== :: GetDASHStreamingSessionURLResponse
-> GetDASHStreamingSessionURLResponse -> Bool
Prelude.Eq, ReadPrec [GetDASHStreamingSessionURLResponse]
ReadPrec GetDASHStreamingSessionURLResponse
Int -> ReadS GetDASHStreamingSessionURLResponse
ReadS [GetDASHStreamingSessionURLResponse]
(Int -> ReadS GetDASHStreamingSessionURLResponse)
-> ReadS [GetDASHStreamingSessionURLResponse]
-> ReadPrec GetDASHStreamingSessionURLResponse
-> ReadPrec [GetDASHStreamingSessionURLResponse]
-> Read GetDASHStreamingSessionURLResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetDASHStreamingSessionURLResponse]
$creadListPrec :: ReadPrec [GetDASHStreamingSessionURLResponse]
readPrec :: ReadPrec GetDASHStreamingSessionURLResponse
$creadPrec :: ReadPrec GetDASHStreamingSessionURLResponse
readList :: ReadS [GetDASHStreamingSessionURLResponse]
$creadList :: ReadS [GetDASHStreamingSessionURLResponse]
readsPrec :: Int -> ReadS GetDASHStreamingSessionURLResponse
$creadsPrec :: Int -> ReadS GetDASHStreamingSessionURLResponse
Prelude.Read, Int -> GetDASHStreamingSessionURLResponse -> ShowS
[GetDASHStreamingSessionURLResponse] -> ShowS
GetDASHStreamingSessionURLResponse -> String
(Int -> GetDASHStreamingSessionURLResponse -> ShowS)
-> (GetDASHStreamingSessionURLResponse -> String)
-> ([GetDASHStreamingSessionURLResponse] -> ShowS)
-> Show GetDASHStreamingSessionURLResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetDASHStreamingSessionURLResponse] -> ShowS
$cshowList :: [GetDASHStreamingSessionURLResponse] -> ShowS
show :: GetDASHStreamingSessionURLResponse -> String
$cshow :: GetDASHStreamingSessionURLResponse -> String
showsPrec :: Int -> GetDASHStreamingSessionURLResponse -> ShowS
$cshowsPrec :: Int -> GetDASHStreamingSessionURLResponse -> ShowS
Prelude.Show, (forall x.
 GetDASHStreamingSessionURLResponse
 -> Rep GetDASHStreamingSessionURLResponse x)
-> (forall x.
    Rep GetDASHStreamingSessionURLResponse x
    -> GetDASHStreamingSessionURLResponse)
-> Generic GetDASHStreamingSessionURLResponse
forall x.
Rep GetDASHStreamingSessionURLResponse x
-> GetDASHStreamingSessionURLResponse
forall x.
GetDASHStreamingSessionURLResponse
-> Rep GetDASHStreamingSessionURLResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetDASHStreamingSessionURLResponse x
-> GetDASHStreamingSessionURLResponse
$cfrom :: forall x.
GetDASHStreamingSessionURLResponse
-> Rep GetDASHStreamingSessionURLResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetDASHStreamingSessionURLResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'dASHStreamingSessionURL', 'getDASHStreamingSessionURLResponse_dASHStreamingSessionURL' - The URL (containing the session token) that a media player can use to
-- retrieve the MPEG-DASH manifest.
--
-- 'httpStatus', 'getDASHStreamingSessionURLResponse_httpStatus' - The response's http status code.
newGetDASHStreamingSessionURLResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetDASHStreamingSessionURLResponse
newGetDASHStreamingSessionURLResponse :: Int -> GetDASHStreamingSessionURLResponse
newGetDASHStreamingSessionURLResponse Int
pHttpStatus_ =
  GetDASHStreamingSessionURLResponse' :: Maybe Text -> Int -> GetDASHStreamingSessionURLResponse
GetDASHStreamingSessionURLResponse'
    { $sel:dASHStreamingSessionURL:GetDASHStreamingSessionURLResponse' :: Maybe Text
dASHStreamingSessionURL =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetDASHStreamingSessionURLResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The URL (containing the session token) that a media player can use to
-- retrieve the MPEG-DASH manifest.
getDASHStreamingSessionURLResponse_dASHStreamingSessionURL :: Lens.Lens' GetDASHStreamingSessionURLResponse (Prelude.Maybe Prelude.Text)
getDASHStreamingSessionURLResponse_dASHStreamingSessionURL :: (Maybe Text -> f (Maybe Text))
-> GetDASHStreamingSessionURLResponse
-> f GetDASHStreamingSessionURLResponse
getDASHStreamingSessionURLResponse_dASHStreamingSessionURL = (GetDASHStreamingSessionURLResponse -> Maybe Text)
-> (GetDASHStreamingSessionURLResponse
    -> Maybe Text -> GetDASHStreamingSessionURLResponse)
-> Lens
     GetDASHStreamingSessionURLResponse
     GetDASHStreamingSessionURLResponse
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURLResponse' {Maybe Text
dASHStreamingSessionURL :: Maybe Text
$sel:dASHStreamingSessionURL:GetDASHStreamingSessionURLResponse' :: GetDASHStreamingSessionURLResponse -> Maybe Text
dASHStreamingSessionURL} -> Maybe Text
dASHStreamingSessionURL) (\s :: GetDASHStreamingSessionURLResponse
s@GetDASHStreamingSessionURLResponse' {} Maybe Text
a -> GetDASHStreamingSessionURLResponse
s {$sel:dASHStreamingSessionURL:GetDASHStreamingSessionURLResponse' :: Maybe Text
dASHStreamingSessionURL = Maybe Text
a} :: GetDASHStreamingSessionURLResponse)

-- | The response's http status code.
getDASHStreamingSessionURLResponse_httpStatus :: Lens.Lens' GetDASHStreamingSessionURLResponse Prelude.Int
getDASHStreamingSessionURLResponse_httpStatus :: (Int -> f Int)
-> GetDASHStreamingSessionURLResponse
-> f GetDASHStreamingSessionURLResponse
getDASHStreamingSessionURLResponse_httpStatus = (GetDASHStreamingSessionURLResponse -> Int)
-> (GetDASHStreamingSessionURLResponse
    -> Int -> GetDASHStreamingSessionURLResponse)
-> Lens
     GetDASHStreamingSessionURLResponse
     GetDASHStreamingSessionURLResponse
     Int
     Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDASHStreamingSessionURLResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetDASHStreamingSessionURLResponse' :: GetDASHStreamingSessionURLResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetDASHStreamingSessionURLResponse
s@GetDASHStreamingSessionURLResponse' {} Int
a -> GetDASHStreamingSessionURLResponse
s {$sel:httpStatus:GetDASHStreamingSessionURLResponse' :: Int
httpStatus = Int
a} :: GetDASHStreamingSessionURLResponse)

instance
  Prelude.NFData
    GetDASHStreamingSessionURLResponse