@pgarbe/cdk-ecr-sync 0.5.25 → 0.5.28

package/node_modules/aws-sdk/clients/kinesisvideo.d.ts

@@ -43,6 +43,22 @@ declare class KinesisVideo extends Service {
    * Deletes a Kinesis video stream and the data contained in the stream.  This method marks the stream for deletion, and makes the data in the stream inaccessible immediately.    To ensure that you have the latest version of the stream before deleting it, you can specify the stream version. Kinesis Video Streams assigns a version to each stream. When you update a stream, Kinesis Video Streams assigns a new version number. To get the latest stream version, use the DescribeStream API.  This operation requires permission for the KinesisVideo:DeleteStream action.
    */
   deleteStream(callback?: (err: AWSError, data: KinesisVideo.Types.DeleteStreamOutput) => void): Request<KinesisVideo.Types.DeleteStreamOutput, AWSError>;
+  /**
+   * Gets the ImageGenerationConfiguration for a given Kinesis video stream.
+   */
+  describeImageGenerationConfiguration(params: KinesisVideo.Types.DescribeImageGenerationConfigurationInput, callback?: (err: AWSError, data: KinesisVideo.Types.DescribeImageGenerationConfigurationOutput) => void): Request<KinesisVideo.Types.DescribeImageGenerationConfigurationOutput, AWSError>;
+  /**
+   * Gets the ImageGenerationConfiguration for a given Kinesis video stream.
+   */
+  describeImageGenerationConfiguration(callback?: (err: AWSError, data: KinesisVideo.Types.DescribeImageGenerationConfigurationOutput) => void): Request<KinesisVideo.Types.DescribeImageGenerationConfigurationOutput, AWSError>;
+  /**
+   * Gets the NotificationConfiguration for a given Kinesis video stream.
+   */
+  describeNotificationConfiguration(params: KinesisVideo.Types.DescribeNotificationConfigurationInput, callback?: (err: AWSError, data: KinesisVideo.Types.DescribeNotificationConfigurationOutput) => void): Request<KinesisVideo.Types.DescribeNotificationConfigurationOutput, AWSError>;
+  /**
+   * Gets the NotificationConfiguration for a given Kinesis video stream.
+   */
+  describeNotificationConfiguration(callback?: (err: AWSError, data: KinesisVideo.Types.DescribeNotificationConfigurationOutput) => void): Request<KinesisVideo.Types.DescribeNotificationConfigurationOutput, AWSError>;
   /**
    * Returns the most current information about the signaling channel. You must specify either the name or the Amazon Resource Name (ARN) of the channel that you want to describe.
    */
@@ -108,19 +124,19 @@ declare class KinesisVideo extends Service {
    */
   listTagsForStream(callback?: (err: AWSError, data: KinesisVideo.Types.ListTagsForStreamOutput) => void): Request<KinesisVideo.Types.ListTagsForStreamOutput, AWSError>;
   /**
-   * Adds one or more tags to a signaling channel. A tag is a key-value pair (the value is optional) that you can define and assign to AWS resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide.
+   * Adds one or more tags to a signaling channel. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the Billing and Cost Management and Cost Management User Guide.
    */
   tagResource(params: KinesisVideo.Types.TagResourceInput, callback?: (err: AWSError, data: KinesisVideo.Types.TagResourceOutput) => void): Request<KinesisVideo.Types.TagResourceOutput, AWSError>;
   /**
-   * Adds one or more tags to a signaling channel. A tag is a key-value pair (the value is optional) that you can define and assign to AWS resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide.
+   * Adds one or more tags to a signaling channel. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the Billing and Cost Management and Cost Management User Guide.
    */
   tagResource(callback?: (err: AWSError, data: KinesisVideo.Types.TagResourceOutput) => void): Request<KinesisVideo.Types.TagResourceOutput, AWSError>;
   /**
-   * Adds one or more tags to a stream. A tag is a key-value pair (the value is optional) that you can define and assign to AWS resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide.  You must provide either the StreamName or the StreamARN. This operation requires permission for the KinesisVideo:TagStream action. Kinesis video streams support up to 50 tags.
+   * Adds one or more tags to a stream. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the Billing and Cost Management and Cost Management User Guide.  You must provide either the StreamName or the StreamARN. This operation requires permission for the KinesisVideo:TagStream action. A Kinesis video stream can support up to 50 tags.
    */
   tagStream(params: KinesisVideo.Types.TagStreamInput, callback?: (err: AWSError, data: KinesisVideo.Types.TagStreamOutput) => void): Request<KinesisVideo.Types.TagStreamOutput, AWSError>;
   /**
-   * Adds one or more tags to a stream. A tag is a key-value pair (the value is optional) that you can define and assign to AWS resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management User Guide.  You must provide either the StreamName or the StreamARN. This operation requires permission for the KinesisVideo:TagStream action. Kinesis video streams support up to 50 tags.
+   * Adds one or more tags to a stream. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see Using Cost Allocation Tags in the Billing and Cost Management and Cost Management User Guide.  You must provide either the StreamName or the StreamARN. This operation requires permission for the KinesisVideo:TagStream action. A Kinesis video stream can support up to 50 tags.
    */
   tagStream(callback?: (err: AWSError, data: KinesisVideo.Types.TagStreamOutput) => void): Request<KinesisVideo.Types.TagStreamOutput, AWSError>;
   /**
@@ -147,6 +163,22 @@ declare class KinesisVideo extends Service {
    *  Increases or decreases the stream's data retention period by the value that you specify. To indicate whether you want to increase or decrease the data retention period, specify the Operation parameter in the request body. In the request, you must specify either the StreamName or the StreamARN.   The retention period that you specify replaces the current value.  This operation requires permission for the KinesisVideo:UpdateDataRetention action. Changing the data retention period affects the data in the stream as follows:   If the data retention period is increased, existing data is retained for the new retention period. For example, if the data retention period is increased from one hour to seven hours, all existing data is retained for seven hours.   If the data retention period is decreased, existing data is retained for the new retention period. For example, if the data retention period is decreased from seven hours to one hour, all existing data is retained for one hour, and any data older than one hour is deleted immediately.  
    */
   updateDataRetention(callback?: (err: AWSError, data: KinesisVideo.Types.UpdateDataRetentionOutput) => void): Request<KinesisVideo.Types.UpdateDataRetentionOutput, AWSError>;
+  /**
+   * Updates the StreamInfo and ImageProcessingConfiguration fields.
+   */
+  updateImageGenerationConfiguration(params: KinesisVideo.Types.UpdateImageGenerationConfigurationInput, callback?: (err: AWSError, data: KinesisVideo.Types.UpdateImageGenerationConfigurationOutput) => void): Request<KinesisVideo.Types.UpdateImageGenerationConfigurationOutput, AWSError>;
+  /**
+   * Updates the StreamInfo and ImageProcessingConfiguration fields.
+   */
+  updateImageGenerationConfiguration(callback?: (err: AWSError, data: KinesisVideo.Types.UpdateImageGenerationConfigurationOutput) => void): Request<KinesisVideo.Types.UpdateImageGenerationConfigurationOutput, AWSError>;
+  /**
+   * Updates the notification information for a stream.
+   */
+  updateNotificationConfiguration(params: KinesisVideo.Types.UpdateNotificationConfigurationInput, callback?: (err: AWSError, data: KinesisVideo.Types.UpdateNotificationConfigurationOutput) => void): Request<KinesisVideo.Types.UpdateNotificationConfigurationOutput, AWSError>;
+  /**
+   * Updates the notification information for a stream.
+   */
+  updateNotificationConfiguration(callback?: (err: AWSError, data: KinesisVideo.Types.UpdateNotificationConfigurationOutput) => void): Request<KinesisVideo.Types.UpdateNotificationConfigurationOutput, AWSError>;
   /**
    * Updates the existing signaling channel. This is an asynchronous operation and takes time to complete.  If the MessageTtlSeconds value is updated (either increased or reduced), it only applies to new messages sent via this channel after it's been updated. Existing messages are still expired as per the previous MessageTtlSeconds value.
    */
@@ -165,7 +197,7 @@ declare class KinesisVideo extends Service {
   updateStream(callback?: (err: AWSError, data: KinesisVideo.Types.UpdateStreamOutput) => void): Request<KinesisVideo.Types.UpdateStreamOutput, AWSError>;
 }
 declare namespace KinesisVideo {
-  export type APIName = "PUT_MEDIA"|"GET_MEDIA"|"LIST_FRAGMENTS"|"GET_MEDIA_FOR_FRAGMENT_LIST"|"GET_HLS_STREAMING_SESSION_URL"|"GET_DASH_STREAMING_SESSION_URL"|"GET_CLIP"|string;
+  export type APIName = "PUT_MEDIA"|"GET_MEDIA"|"LIST_FRAGMENTS"|"GET_MEDIA_FOR_FRAGMENT_LIST"|"GET_HLS_STREAMING_SESSION_URL"|"GET_DASH_STREAMING_SESSION_URL"|"GET_CLIP"|"GET_IMAGES"|string;
   export interface ChannelInfo {
     /**
      * The name of the signaling channel.
@@ -210,11 +242,12 @@ declare namespace KinesisVideo {
   }
   export type ChannelProtocol = "WSS"|"HTTPS"|string;
   export type ChannelRole = "MASTER"|"VIEWER"|string;
-  export type ChannelType = "SINGLE_MASTER"|string;
+  export type ChannelType = "SINGLE_MASTER"|"FULL_MESH"|string;
   export type ComparisonOperator = "BEGINS_WITH"|string;
+  export type ConfigurationStatus = "ENABLED"|"DISABLED"|string;
   export interface CreateSignalingChannelInput {
     /**
-     * A name for the signaling channel that you are creating. It must be unique for each AWS account and AWS Region.
+     * A name for the signaling channel that you are creating. It must be unique for each Amazon Web Services account and Amazon Web Services Region.
      */
     ChannelName: ChannelName;
     /**
@@ -250,7 +283,7 @@ declare namespace KinesisVideo {
      */
     MediaType?: MediaType;
     /**
-     * The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis Video Streams to use to encrypt stream data. If no key ID is specified, the default, Kinesis Video-managed key (aws/kinesisvideo) is used.  For more information, see DescribeKey. 
+     * The ID of the Key Management Service (KMS) key that you want Kinesis Video Streams to use to encrypt stream data. If no key ID is specified, the default, Kinesis Video-managed key (aws/kinesisvideo) is used.  For more information, see DescribeKey. 
      */
     KmsKeyId?: KmsKeyId;
     /**
@@ -295,6 +328,38 @@ declare namespace KinesisVideo {
   }
   export interface DeleteStreamOutput {
   }
+  export interface DescribeImageGenerationConfigurationInput {
+    /**
+     * The name of the stream from which to retrieve the image generation configuration. You must specify either the StreamName or the StreamARN. 
+     */
+    StreamName?: StreamName;
+    /**
+     * The Amazon Resource Name (ARN) of the Kinesis video stream from which to retrieve the image generation configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamARN?: ResourceARN;
+  }
+  export interface DescribeImageGenerationConfigurationOutput {
+    /**
+     * The structure that contains the information required for the Kinesis video stream (KVS) images delivery. If this structure is null, the configuration will be deleted from the stream.
+     */
+    ImageGenerationConfiguration?: ImageGenerationConfiguration;
+  }
+  export interface DescribeNotificationConfigurationInput {
+    /**
+     * The name of the stream from which to retrieve the notification configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamName?: StreamName;
+    /**
+     * The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to retrieve the notification configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamARN?: ResourceARN;
+  }
+  export interface DescribeNotificationConfigurationOutput {
+    /**
+     * The structure that contains the information required for notifications. If the structure is null, the configuration will be deleted from the stream.
+     */
+    NotificationConfiguration?: NotificationConfiguration;
+  }
   export interface DescribeSignalingChannelInput {
     /**
      * The name of the signaling channel that you want to describe.
@@ -327,7 +392,13 @@ declare namespace KinesisVideo {
      */
     StreamInfo?: StreamInfo;
   }
+  export type DestinationRegion = string;
+  export type DestinationUri = string;
   export type DeviceName = string;
+  export type Format = "JPEG"|"PNG"|string;
+  export type FormatConfig = {[key: string]: FormatConfigValue};
+  export type FormatConfigKey = "JPEGQuality"|string;
+  export type FormatConfigValue = string;
   export interface GetDataEndpointInput {
     /**
      * The name of the stream that you want to get the endpoint for. You must specify either this parameter or a StreamARN in the request.
@@ -364,6 +435,52 @@ declare namespace KinesisVideo {
      */
     ResourceEndpointList?: ResourceEndpointList;
   }
+  export type HeightPixels = number;
+  export interface ImageGenerationConfiguration {
+    /**
+     * Indicates whether the ContinuousImageGenerationConfigurations API is enabled or disabled.
+     */
+    Status: ConfigurationStatus;
+    /**
+     * The origin of the Server or Producer timestamps to use to generate the images.
+     */
+    ImageSelectorType: ImageSelectorType;
+    /**
+     * The structure that contains the information required to deliver images to a customer.
+     */
+    DestinationConfig: ImageGenerationDestinationConfig;
+    /**
+     * The time interval in milliseconds (ms) at which the images need to be generated from the stream. The minimum value that can be provided is 33 ms, because a camera that generates content at 30 FPS would create a frame every 33.3 ms. If the timestamp range is less than the sampling interval, the Image from the StartTimestamp will be returned if available. 
+     */
+    SamplingInterval: SamplingInterval;
+    /**
+     * The accepted image format.
+     */
+    Format: Format;
+    /**
+     * The list of a key-value pair structure that contains extra parameters that can be applied when the image is generated. The FormatConfig key is the JPEGQuality, which indicates the JPEG quality key to be used to generate the image. The FormatConfig value accepts ints from 1 to 100. If the value is 1, the image will be generated with less quality and the best compression. If the value is 100, the image will be generated with the best quality and less compression. If no value is provided, the default value of the JPEGQuality key will be set to 80.
+     */
+    FormatConfig?: FormatConfig;
+    /**
+     * The width of the output image that is used in conjunction with the HeightPixels parameter. When both WidthPixels and HeightPixels parameters are provided, the image will be stretched to fit the specified aspect ratio. If only the WidthPixels parameter is provided, its original aspect ratio will be used to calculate the HeightPixels ratio. If neither parameter is provided, the original image size will be returned.
+     */
+    WidthPixels?: WidthPixels;
+    /**
+     * The height of the output image that is used in conjunction with the WidthPixels parameter. When both HeightPixels and WidthPixels parameters are provided, the image will be stretched to fit the specified aspect ratio. If only the HeightPixels parameter is provided, its original aspect ratio will be used to calculate the WidthPixels ratio. If neither parameter is provided, the original image size will be returned.
+     */
+    HeightPixels?: HeightPixels;
+  }
+  export interface ImageGenerationDestinationConfig {
+    /**
+     * The Uniform Resource Idenifier (URI) that identifies where the images will be delivered.
+     */
+    Uri: DestinationUri;
+    /**
+     * The AWS Region of the S3 bucket where images will be delivered. This DestinationRegion must match the Region where the stream is located.
+     */
+    DestinationRegion: DestinationRegion;
+  }
+  export type ImageSelectorType = "SERVER_TIMESTAMP"|"PRODUCER_TIMESTAMP"|string;
   export type KmsKeyId = string;
   export type ListOfProtocols = ChannelProtocol[];
   export interface ListSignalingChannelsInput {
@@ -462,6 +579,22 @@ declare namespace KinesisVideo {
   export type MediaType = string;
   export type MessageTtlSeconds = number;
   export type NextToken = string;
+  export interface NotificationConfiguration {
+    /**
+     * Indicates if a notification configuration is enabled or disabled.
+     */
+    Status: ConfigurationStatus;
+    /**
+     * The destination information required to deliver a notification to a customer.
+     */
+    DestinationConfig: NotificationDestinationConfig;
+  }
+  export interface NotificationDestinationConfig {
+    /**
+     * The Uniform Resource Idenifier (URI) that identifies where the images will be delivered.
+     */
+    Uri: DestinationUri;
+  }
   export type ResourceARN = string;
   export type ResourceEndpoint = string;
   export type ResourceEndpointList = ResourceEndpointListItem[];
@@ -476,6 +609,7 @@ declare namespace KinesisVideo {
     ResourceEndpoint?: ResourceEndpoint;
   }
   export type ResourceTags = {[key: string]: TagValue};
+  export type SamplingInterval = number;
   export interface SingleMasterChannelEndpointConfiguration {
     /**
      * This property is used to determine the nature of communication over this SINGLE_MASTER signaling channel. If WSS is specified, this API returns a websocket endpoint. If HTTPS is specified, this API returns an HTTPS endpoint.
@@ -488,7 +622,7 @@ declare namespace KinesisVideo {
   }
   export interface SingleMasterConfiguration {
     /**
-     * The period of time a signaling channel retains underlivered messages before they are discarded.
+     * The period of time a signaling channel retains undelivered messages before they are discarded.
      */
     MessageTtlSeconds?: MessageTtlSeconds;
   }
@@ -511,7 +645,7 @@ declare namespace KinesisVideo {
      */
     MediaType?: MediaType;
     /**
-     * The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video Streams uses to encrypt data on the stream.
+     * The ID of the Key Management Service (KMS) key that Kinesis Video Streams uses to encrypt data on the stream.
      */
     KmsKeyId?: KmsKeyId;
     /**
@@ -640,6 +774,38 @@ declare namespace KinesisVideo {
   export type UpdateDataRetentionOperation = "INCREASE_DATA_RETENTION"|"DECREASE_DATA_RETENTION"|string;
   export interface UpdateDataRetentionOutput {
   }
+  export interface UpdateImageGenerationConfigurationInput {
+    /**
+     * The name of the stream from which to update the image generation configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamName?: StreamName;
+    /**
+     * The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to update the image generation configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamARN?: ResourceARN;
+    /**
+     * The structure that contains the information required for the KVS images delivery. If the structure is null, the configuration will be deleted from the stream.
+     */
+    ImageGenerationConfiguration?: ImageGenerationConfiguration;
+  }
+  export interface UpdateImageGenerationConfigurationOutput {
+  }
+  export interface UpdateNotificationConfigurationInput {
+    /**
+     * The name of the stream from which to update the notification configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamName?: StreamName;
+    /**
+     * The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to update the notification configuration. You must specify either the StreamName or the StreamARN.
+     */
+    StreamARN?: ResourceARN;
+    /**
+     * The structure containing the information required for notifications. If the structure is null, the configuration will be deleted from the stream.
+     */
+    NotificationConfiguration?: NotificationConfiguration;
+  }
+  export interface UpdateNotificationConfigurationOutput {
+  }
   export interface UpdateSignalingChannelInput {
     /**
      * The Amazon Resource Name (ARN) of the signaling channel that you want to update.
@@ -681,6 +847,7 @@ declare namespace KinesisVideo {
   export interface UpdateStreamOutput {
   }
   export type Version = string;
+  export type WidthPixels = number;
   /**
    * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
    */

package/node_modules/aws-sdk/clients/kinesisvideoarchivedmedia.d.ts

@@ -36,6 +36,14 @@ declare class KinesisVideoArchivedMedia extends Service {
    * Retrieves an HTTP Live Streaming (HLS) URL for the stream. You can then open the URL in a browser or 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 HLS:   The media must contain h.264 or h.265 encoded video and, optionally, AAC encoded audio. Specifically, the codec ID of track 1 should be V_MPEG/ISO/AVC (for h.264) or V_MPEG/ISO/HEVC (for h.265). Optionally, the codec ID of track 2 should be A_AAC.   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 or HEVC for H.265 format (MPEG-4 specification ISO/IEC 14496-15). For information about adapting stream data to a given format, see NAL Adaptation Flags.   The audio track (if present) of each fragment must contain codec private data in the AAC format (AAC specification ISO/IEC 13818-7).   Kinesis Video Streams HLS sessions contain fragments in the fragmented MPEG-4 form (also called fMP4 or CMAF) or the MPEG-2 form (also called TS chunks, which the HLS specification also supports). For more information about HLS fragment types, see the HLS specification. The following procedure shows how to use HLS with Kinesis Video Streams:   Get an endpoint using GetDataEndpoint, specifying GET_HLS_STREAMING_SESSION_URL for the APIName parameter.   Retrieve the HLS URL using GetHLSStreamingSessionURL. Kinesis Video Streams creates an HLS streaming session to be used for accessing content in a stream using the HLS protocol. GetHLSStreamingSessionURL returns an authenticated URL (that includes an encrypted session token) for the session's HLS master playlist (the root resource needed for streaming with HLS).  Don't share or store this token where an unauthorized entity could access it. The token provides access to the content of the stream. Safeguard the token with the same measures that you would use with your AWS credentials.  The media that is made available through the playlist 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.   Provide the URL (containing the encrypted session token) for the HLS master playlist to a media player that supports the HLS protocol. Kinesis Video Streams makes the HLS media playlist, initialization fragment, and media fragments available through the master playlist 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 H.264-encoded video frames or AAC-encoded audio samples.   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:    GetHLSMasterPlaylist: Retrieves an HLS master playlist, which contains a URL for the GetHLSMediaPlaylist action for each track, and additional metadata for the media player, including estimated bitrate and resolution.    GetHLSMediaPlaylist: Retrieves an HLS media playlist, which contains a URL to access the MP4 initialization fragment with the GetMP4InitFragment action, and URLs to access the MP4 media fragments with the GetMP4MediaFragment actions. The HLS media playlist also contains metadata about the stream that the player needs to play it, such as whether the PlaybackMode is LIVE or ON_DEMAND. The HLS media playlist is typically static for sessions with a PlaybackType of ON_DEMAND. The HLS media playlist is continually updated with new fragments for sessions with a PlaybackType of LIVE. There is a distinct HLS media playlist for the video track and the audio track (if applicable) that contains MP4 media URLs for the specific track.     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 Pricing for details.    GetTSFragment: Retrieves MPEG TS fragments containing both initialization and media data for all tracks in the stream.  If the ContainerFormat is MPEG_TS, this API is used instead of GetMP4InitFragment and GetMP4MediaFragment to retrieve stream media.  Data retrieved with this action is billable. For more information, see Kinesis Video Streams pricing.     A streaming session URL must not be shared between players. The service might throttle a session if multiple media players are sharing it. For connection limits, see 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 Monitoring Kinesis Video Streams. For pricing information, see Amazon Kinesis Video Streams Pricing and AWS Pricing. Charges for both HLS sessions and outgoing AWS data apply. For more information about HLS, see HTTP Live Streaming on the 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 Common Errors.  
    */
   getHLSStreamingSessionURL(callback?: (err: AWSError, data: KinesisVideoArchivedMedia.Types.GetHLSStreamingSessionURLOutput) => void): Request<KinesisVideoArchivedMedia.Types.GetHLSStreamingSessionURLOutput, AWSError>;
+  /**
+   * Retrieves a list of Images corresponding to each timestamp for a given time range, sampling interval, and image format configuration.
+   */
+  getImages(params: KinesisVideoArchivedMedia.Types.GetImagesInput, callback?: (err: AWSError, data: KinesisVideoArchivedMedia.Types.GetImagesOutput) => void): Request<KinesisVideoArchivedMedia.Types.GetImagesOutput, AWSError>;
+  /**
+   * Retrieves a list of Images corresponding to each timestamp for a given time range, sampling interval, and image format configuration.
+   */
+  getImages(callback?: (err: AWSError, data: KinesisVideoArchivedMedia.Types.GetImagesOutput) => void): Request<KinesisVideoArchivedMedia.Types.GetImagesOutput, AWSError>;
   /**
    * Gets media for a list of fragments (specified by fragment number) from the archived data in an Amazon Kinesis video stream.  You must first call the GetDataEndpoint API to get an endpoint. Then send the GetMediaForFragmentList requests to this endpoint using the --endpoint-url parameter.   For limits, see Kinesis Video Streams Limits.  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 Common Errors.  
    */
@@ -104,6 +112,10 @@ declare namespace KinesisVideoArchivedMedia {
     EndTimestamp?: Timestamp;
   }
   export type Expires = number;
+  export type Format = "JPEG"|"PNG"|string;
+  export type FormatConfig = {[key: string]: FormatConfigValue};
+  export type FormatConfigKey = "JPEGQuality"|string;
+  export type FormatConfigValue = string;
   export interface Fragment {
     /**
      * The unique identifier of the fragment. This value monotonically increases based on the ingestion order.
@@ -248,6 +260,67 @@ declare namespace KinesisVideoArchivedMedia {
      */
     HLSStreamingSessionURL?: HLSStreamingSessionURL;
   }
+  export interface GetImagesInput {
+    /**
+     * The name of the stream from which to retrieve the images. You must specify either the StreamName or the StreamARN.
+     */
+    StreamName?: StreamName;
+    /**
+     * The Amazon Resource Name (ARN) of the stream from which to retrieve the images. You must specify either the StreamName or the StreamARN.
+     */
+    StreamARN?: ResourceARN;
+    /**
+     * The origin of the Server or Producer timestamps to use to generate the images.
+     */
+    ImageSelectorType: ImageSelectorType;
+    /**
+     * The starting point from which the images should be generated. This StartTimestamp must be within an inclusive range of timestamps for an image to be returned.
+     */
+    StartTimestamp: Timestamp;
+    /**
+     * The end timestamp for the range of images to be generated.
+     */
+    EndTimestamp: Timestamp;
+    /**
+     * The time interval in milliseconds (ms) at which the images need to be generated from the stream. The minimum value that can be provided is 3000 ms. If the timestamp range is less than the sampling interval, the Image from the startTimestamp will be returned if available.   The minimum value of 3000 ms is a soft limit. If needed, a lower sampling frequency can be requested. 
+     */
+    SamplingInterval: SamplingInterval;
+    /**
+     * The format that will be used to encode the image.
+     */
+    Format: Format;
+    /**
+     * The list of a key-value pair structure that contains extra parameters that can be applied when the image is generated. The FormatConfig key is the JPEGQuality, which indicates the JPEG quality key to be used to generate the image. The FormatConfig value accepts ints from 1 to 100. If the value is 1, the image will be generated with less quality and the best compression. If the value is 100, the image will be generated with the best quality and less compression. If no value is provided, the default value of the JPEGQuality key will be set to 80.
+     */
+    FormatConfig?: FormatConfig;
+    /**
+     * The width of the output image that is used in conjunction with the HeightPixels parameter. When both WidthPixels and HeightPixels parameters are provided, the image will be stretched to fit the specified aspect ratio. If only the WidthPixels parameter is provided or if only the HeightPixels is provided, a ValidationException will be thrown. If neither parameter is provided, the original image size from the stream will be returned.
+     */
+    WidthPixels?: WidthPixels;
+    /**
+     * The height of the output image that is used in conjunction with the WidthPixels parameter. When both HeightPixels and WidthPixels parameters are provided, the image will be stretched to fit the specified aspect ratio. If only the HeightPixels parameter is provided, its original aspect ratio will be used to calculate the WidthPixels ratio. If neither parameter is provided, the original image size will be returned.
+     */
+    HeightPixels?: HeightPixels;
+    /**
+     * The maximum number of images to be returned by the API.   The default limit is 100 images per API response. The additional results will be paginated.  
+     */
+    MaxResults?: GetImagesMaxResults;
+    /**
+     * A token that specifies where to start paginating the next set of Images. This is the GetImages:NextToken from a previously truncated response.
+     */
+    NextToken?: NextToken;
+  }
+  export type GetImagesMaxResults = number;
+  export interface GetImagesOutput {
+    /**
+     * The list of images generated from the video stream. If there is no media available for the given timestamp, the NO_MEDIA error will be listed in the output. If an error occurs while the image is being generated, the MEDIA_ERROR will be listed in the output as the cause of the missing image. 
+     */
+    Images?: Images;
+    /**
+     * The encrypted token that was used in the request to get more images.
+     */
+    NextToken?: NextToken;
+  }
   export interface GetMediaForFragmentListInput {
     /**
      * The name of the stream from which to retrieve fragment media. Specify either this parameter or the StreamARN parameter.
@@ -298,6 +371,25 @@ declare namespace KinesisVideoArchivedMedia {
      */
     EndTimestamp?: Timestamp;
   }
+  export type HeightPixels = number;
+  export interface Image {
+    /**
+     * An attribute of the Image object that is used to extract an image from the video stream. This field is used to manage gaps on images or to better understand the pagination window.
+     */
+    TimeStamp?: Timestamp;
+    /**
+     * The error message shown when the image for the provided timestamp was not extracted due to a non-tryable error. An error will be returned if:    There is no media that exists for the specified Timestamp.     The media for the specified time does not allow an image to be extracted. In this case the media is audio only, or the incorrect media has been ingested.  
+     */
+    Error?: ImageError;
+    /**
+     * An attribute of the Image object that is Base64 encoded.
+     */
+    ImageContent?: ImageContent;
+  }
+  export type ImageContent = string;
+  export type ImageError = "NO_MEDIA"|"MEDIA_ERROR"|string;
+  export type ImageSelectorType = "PRODUCER_TIMESTAMP"|"SERVER_TIMESTAMP"|string;
+  export type Images = Image[];
   export interface ListFragmentsInput {
     /**
      * The name of the stream from which to retrieve a fragment list. Specify either this parameter or the StreamARN parameter.
@@ -335,6 +427,7 @@ declare namespace KinesisVideoArchivedMedia {
   export type NextToken = string;
   export type Payload = Buffer|Uint8Array|Blob|string|Readable;
   export type ResourceARN = string;
+  export type SamplingInterval = number;
   export type StreamName = string;
   export type Timestamp = Date;
   export interface TimestampRange {
@@ -347,6 +440,7 @@ declare namespace KinesisVideoArchivedMedia {
      */
     EndTimestamp: Timestamp;
   }
+  export type WidthPixels = number;
   /**
    * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
    */