@aws-sdk/client-kinesis-video 3.80.0 → 3.83.0

package/dist-types/KinesisVideoClient.d.ts

@@ -10,6 +10,8 @@ import { CreateSignalingChannelCommandInput, CreateSignalingChannelCommandOutput
 import { CreateStreamCommandInput, CreateStreamCommandOutput } from "./commands/CreateStreamCommand";
 import { DeleteSignalingChannelCommandInput, DeleteSignalingChannelCommandOutput } from "./commands/DeleteSignalingChannelCommand";
 import { DeleteStreamCommandInput, DeleteStreamCommandOutput } from "./commands/DeleteStreamCommand";
+import { DescribeImageGenerationConfigurationCommandInput, DescribeImageGenerationConfigurationCommandOutput } from "./commands/DescribeImageGenerationConfigurationCommand";
+import { DescribeNotificationConfigurationCommandInput, DescribeNotificationConfigurationCommandOutput } from "./commands/DescribeNotificationConfigurationCommand";
 import { DescribeSignalingChannelCommandInput, DescribeSignalingChannelCommandOutput } from "./commands/DescribeSignalingChannelCommand";
 import { DescribeStreamCommandInput, DescribeStreamCommandOutput } from "./commands/DescribeStreamCommand";
 import { GetDataEndpointCommandInput, GetDataEndpointCommandOutput } from "./commands/GetDataEndpointCommand";
@@ -23,10 +25,12 @@ import { TagStreamCommandInput, TagStreamCommandOutput } from "./commands/TagStr
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UntagStreamCommandInput, UntagStreamCommandOutput } from "./commands/UntagStreamCommand";
 import { UpdateDataRetentionCommandInput, UpdateDataRetentionCommandOutput } from "./commands/UpdateDataRetentionCommand";
+import { UpdateImageGenerationConfigurationCommandInput, UpdateImageGenerationConfigurationCommandOutput } from "./commands/UpdateImageGenerationConfigurationCommand";
+import { UpdateNotificationConfigurationCommandInput, UpdateNotificationConfigurationCommandOutput } from "./commands/UpdateNotificationConfigurationCommand";
 import { UpdateSignalingChannelCommandInput, UpdateSignalingChannelCommandOutput } from "./commands/UpdateSignalingChannelCommand";
 import { UpdateStreamCommandInput, UpdateStreamCommandOutput } from "./commands/UpdateStreamCommand";
-export declare type ServiceInputTypes = CreateSignalingChannelCommandInput | CreateStreamCommandInput | DeleteSignalingChannelCommandInput | DeleteStreamCommandInput | DescribeSignalingChannelCommandInput | DescribeStreamCommandInput | GetDataEndpointCommandInput | GetSignalingChannelEndpointCommandInput | ListSignalingChannelsCommandInput | ListStreamsCommandInput | ListTagsForResourceCommandInput | ListTagsForStreamCommandInput | TagResourceCommandInput | TagStreamCommandInput | UntagResourceCommandInput | UntagStreamCommandInput | UpdateDataRetentionCommandInput | UpdateSignalingChannelCommandInput | UpdateStreamCommandInput;
-export declare type ServiceOutputTypes = CreateSignalingChannelCommandOutput | CreateStreamCommandOutput | DeleteSignalingChannelCommandOutput | DeleteStreamCommandOutput | DescribeSignalingChannelCommandOutput | DescribeStreamCommandOutput | GetDataEndpointCommandOutput | GetSignalingChannelEndpointCommandOutput | ListSignalingChannelsCommandOutput | ListStreamsCommandOutput | ListTagsForResourceCommandOutput | ListTagsForStreamCommandOutput | TagResourceCommandOutput | TagStreamCommandOutput | UntagResourceCommandOutput | UntagStreamCommandOutput | UpdateDataRetentionCommandOutput | UpdateSignalingChannelCommandOutput | UpdateStreamCommandOutput;
+export declare type ServiceInputTypes = CreateSignalingChannelCommandInput | CreateStreamCommandInput | DeleteSignalingChannelCommandInput | DeleteStreamCommandInput | DescribeImageGenerationConfigurationCommandInput | DescribeNotificationConfigurationCommandInput | DescribeSignalingChannelCommandInput | DescribeStreamCommandInput | GetDataEndpointCommandInput | GetSignalingChannelEndpointCommandInput | ListSignalingChannelsCommandInput | ListStreamsCommandInput | ListTagsForResourceCommandInput | ListTagsForStreamCommandInput | TagResourceCommandInput | TagStreamCommandInput | UntagResourceCommandInput | UntagStreamCommandInput | UpdateDataRetentionCommandInput | UpdateImageGenerationConfigurationCommandInput | UpdateNotificationConfigurationCommandInput | UpdateSignalingChannelCommandInput | UpdateStreamCommandInput;
+export declare type ServiceOutputTypes = CreateSignalingChannelCommandOutput | CreateStreamCommandOutput | DeleteSignalingChannelCommandOutput | DeleteStreamCommandOutput | DescribeImageGenerationConfigurationCommandOutput | DescribeNotificationConfigurationCommandOutput | DescribeSignalingChannelCommandOutput | DescribeStreamCommandOutput | GetDataEndpointCommandOutput | GetSignalingChannelEndpointCommandOutput | ListSignalingChannelsCommandOutput | ListStreamsCommandOutput | ListTagsForResourceCommandOutput | ListTagsForStreamCommandOutput | TagResourceCommandOutput | TagStreamCommandOutput | UntagResourceCommandOutput | UntagStreamCommandOutput | UpdateDataRetentionCommandOutput | UpdateImageGenerationConfigurationCommandOutput | UpdateNotificationConfigurationCommandOutput | UpdateSignalingChannelCommandOutput | UpdateStreamCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.

package/dist-types/commands/DescribeImageGenerationConfigurationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KinesisVideoClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisVideoClient";
+import { DescribeImageGenerationConfigurationInput, DescribeImageGenerationConfigurationOutput } from "../models/models_0";
+export interface DescribeImageGenerationConfigurationCommandInput extends DescribeImageGenerationConfigurationInput {
+}
+export interface DescribeImageGenerationConfigurationCommandOutput extends DescribeImageGenerationConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the <code>ImageGenerationConfiguration</code> for a given Kinesis video stream.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { KinesisVideoClient, DescribeImageGenerationConfigurationCommand } from "@aws-sdk/client-kinesis-video"; // ES Modules import
+ * // const { KinesisVideoClient, DescribeImageGenerationConfigurationCommand } = require("@aws-sdk/client-kinesis-video"); // CommonJS import
+ * const client = new KinesisVideoClient(config);
+ * const command = new DescribeImageGenerationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeImageGenerationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link DescribeImageGenerationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link KinesisVideoClientResolvedConfig | config} for KinesisVideoClient's `config` shape.
+ *
+ */
+export declare class DescribeImageGenerationConfigurationCommand extends $Command<DescribeImageGenerationConfigurationCommandInput, DescribeImageGenerationConfigurationCommandOutput, KinesisVideoClientResolvedConfig> {
+    readonly input: DescribeImageGenerationConfigurationCommandInput;
+    constructor(input: DescribeImageGenerationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisVideoClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeImageGenerationConfigurationCommandInput, DescribeImageGenerationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeNotificationConfigurationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KinesisVideoClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisVideoClient";
+import { DescribeNotificationConfigurationInput, DescribeNotificationConfigurationOutput } from "../models/models_0";
+export interface DescribeNotificationConfigurationCommandInput extends DescribeNotificationConfigurationInput {
+}
+export interface DescribeNotificationConfigurationCommandOutput extends DescribeNotificationConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the <code>NotificationConfiguration</code> for a given Kinesis video stream.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { KinesisVideoClient, DescribeNotificationConfigurationCommand } from "@aws-sdk/client-kinesis-video"; // ES Modules import
+ * // const { KinesisVideoClient, DescribeNotificationConfigurationCommand } = require("@aws-sdk/client-kinesis-video"); // CommonJS import
+ * const client = new KinesisVideoClient(config);
+ * const command = new DescribeNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link DescribeNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link KinesisVideoClientResolvedConfig | config} for KinesisVideoClient's `config` shape.
+ *
+ */
+export declare class DescribeNotificationConfigurationCommand extends $Command<DescribeNotificationConfigurationCommandInput, DescribeNotificationConfigurationCommandOutput, KinesisVideoClientResolvedConfig> {
+    readonly input: DescribeNotificationConfigurationCommandInput;
+    constructor(input: DescribeNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisVideoClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeNotificationConfigurationCommandInput, DescribeNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSignalingChannelEndpointCommand.d.ts

@@ -19,8 +19,8 @@ export interface GetSignalingChannelEndpointCommandOutput extends GetSignalingCh
  *             <code>Role</code> determines the messaging permissions. A <code>MASTER</code> role
  *             results in this API generating an endpoint that a client can use to communicate with any
  *             of the viewers on the channel. A <code>VIEWER</code> role results in this API generating
- *             an endpoint that a client can use to communicate only with a
- *                 <code>MASTER</code>. </p>
+ *             an endpoint that a client can use to communicate only with a <code>MASTER</code>.
+ *         </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/ListSignalingChannelsCommand.d.ts

@@ -8,8 +8,8 @@ export interface ListSignalingChannelsCommandOutput extends ListSignalingChannel
 }
 /**
  * <p>Returns an array of <code>ChannelInfo</code> objects. Each object describes a
- *             signaling channel. To retrieve only those channels that satisfy a specific condition, you can
- *             specify a <code>ChannelNameCondition</code>.</p>
+ *             signaling channel. To retrieve only those channels that satisfy a specific condition,
+ *             you can specify a <code>ChannelNameCondition</code>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/TagResourceCommand.d.ts

@@ -8,10 +8,10 @@ export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataB
 }
 /**
  * <p>Adds one or more tags to a signaling channel. A <i>tag</i> is a
- *             key-value pair (the value is optional) that you can define and assign to AWS resources.
+ *             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 <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using Cost Allocation
- *                 Tags</a> in the <i>AWS Billing and Cost Management User
+ *                 Tags</a> in the <i>Billing and Cost Management and Cost Management User
  *             Guide</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/TagStreamCommand.d.ts

@@ -8,15 +8,15 @@ export interface TagStreamCommandOutput extends TagStreamOutput, __MetadataBeare
 }
 /**
  * <p>Adds one or more tags to a stream. A <i>tag</i> is a key-value pair
- *             (the value is optional) that you can define and assign to AWS resources. If you specify
+ *             (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 <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using Cost Allocation
- *                 Tags</a> in the <i>AWS Billing and Cost Management User Guide</i>. </p>
+ *                 Tags</a> in the <i>Billing and Cost Management and Cost Management User Guide</i>. </p>
  *         <p>You must provide either the <code>StreamName</code> or the
  *             <code>StreamARN</code>.</p>
  *         <p>This operation requires permission for the <code>KinesisVideo:TagStream</code>
  *             action.</p>
- *         <p>Kinesis video streams support up to 50 tags.</p>
+ *         <p>A Kinesis video stream can support up to 50 tags.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/UpdateImageGenerationConfigurationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KinesisVideoClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisVideoClient";
+import { UpdateImageGenerationConfigurationInput, UpdateImageGenerationConfigurationOutput } from "../models/models_0";
+export interface UpdateImageGenerationConfigurationCommandInput extends UpdateImageGenerationConfigurationInput {
+}
+export interface UpdateImageGenerationConfigurationCommandOutput extends UpdateImageGenerationConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the <code>StreamInfo</code> and <code>ImageProcessingConfiguration</code> fields.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { KinesisVideoClient, UpdateImageGenerationConfigurationCommand } from "@aws-sdk/client-kinesis-video"; // ES Modules import
+ * // const { KinesisVideoClient, UpdateImageGenerationConfigurationCommand } = require("@aws-sdk/client-kinesis-video"); // CommonJS import
+ * const client = new KinesisVideoClient(config);
+ * const command = new UpdateImageGenerationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateImageGenerationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link UpdateImageGenerationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link KinesisVideoClientResolvedConfig | config} for KinesisVideoClient's `config` shape.
+ *
+ */
+export declare class UpdateImageGenerationConfigurationCommand extends $Command<UpdateImageGenerationConfigurationCommandInput, UpdateImageGenerationConfigurationCommandOutput, KinesisVideoClientResolvedConfig> {
+    readonly input: UpdateImageGenerationConfigurationCommandInput;
+    constructor(input: UpdateImageGenerationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisVideoClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateImageGenerationConfigurationCommandInput, UpdateImageGenerationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateNotificationConfigurationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KinesisVideoClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisVideoClient";
+import { UpdateNotificationConfigurationInput, UpdateNotificationConfigurationOutput } from "../models/models_0";
+export interface UpdateNotificationConfigurationCommandInput extends UpdateNotificationConfigurationInput {
+}
+export interface UpdateNotificationConfigurationCommandOutput extends UpdateNotificationConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the notification information for a stream.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { KinesisVideoClient, UpdateNotificationConfigurationCommand } from "@aws-sdk/client-kinesis-video"; // ES Modules import
+ * // const { KinesisVideoClient, UpdateNotificationConfigurationCommand } = require("@aws-sdk/client-kinesis-video"); // CommonJS import
+ * const client = new KinesisVideoClient(config);
+ * const command = new UpdateNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link UpdateNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link KinesisVideoClientResolvedConfig | config} for KinesisVideoClient's `config` shape.
+ *
+ */
+export declare class UpdateNotificationConfigurationCommand extends $Command<UpdateNotificationConfigurationCommandInput, UpdateNotificationConfigurationCommandOutput, KinesisVideoClientResolvedConfig> {
+    readonly input: UpdateNotificationConfigurationCommandInput;
+    constructor(input: UpdateNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisVideoClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateNotificationConfigurationCommandInput, UpdateNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -2,6 +2,8 @@ export * from "./CreateSignalingChannelCommand";
 export * from "./CreateStreamCommand";
 export * from "./DeleteSignalingChannelCommand";
 export * from "./DeleteStreamCommand";
+export * from "./DescribeImageGenerationConfigurationCommand";
+export * from "./DescribeNotificationConfigurationCommand";
 export * from "./DescribeSignalingChannelCommand";
 export * from "./DescribeStreamCommand";
 export * from "./GetDataEndpointCommand";
@@ -15,5 +17,7 @@ export * from "./TagStreamCommand";
 export * from "./UntagResourceCommand";
 export * from "./UntagStreamCommand";
 export * from "./UpdateDataRetentionCommand";
+export * from "./UpdateImageGenerationConfigurationCommand";
+export * from "./UpdateNotificationConfigurationCommand";
 export * from "./UpdateSignalingChannelCommand";
 export * from "./UpdateStreamCommand";

package/dist-types/models/models_0.d.ts

@@ -13,7 +13,7 @@ export declare class AccessDeniedException extends __BaseException {
     constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
 }
 /**
- * <p>You have reached the maximum limit of active signaling channels for this AWS account
+ * <p>You have reached the maximum limit of active signaling channels for this Amazon Web Services account
  *             in this region.</p>
  */
 export declare class AccountChannelLimitExceededException extends __BaseException {
@@ -41,6 +41,7 @@ export declare enum APIName {
     GET_CLIP = "GET_CLIP",
     GET_DASH_STREAMING_SESSION_URL = "GET_DASH_STREAMING_SESSION_URL",
     GET_HLS_STREAMING_SESSION_URL = "GET_HLS_STREAMING_SESSION_URL",
+    GET_IMAGES = "GET_IMAGES",
     GET_MEDIA = "GET_MEDIA",
     GET_MEDIA_FOR_FRAGMENT_LIST = "GET_MEDIA_FOR_FRAGMENT_LIST",
     LIST_FRAGMENTS = "LIST_FRAGMENTS",
@@ -53,6 +54,7 @@ export declare enum Status {
     UPDATING = "UPDATING"
 }
 export declare enum ChannelType {
+    FULL_MESH = "FULL_MESH",
     SINGLE_MASTER = "SINGLE_MASTER"
 }
 /**
@@ -61,7 +63,7 @@ export declare enum ChannelType {
  */
 export interface SingleMasterConfiguration {
     /**
-     * <p>The period of time a signaling channel retains underlivered messages before they are
+     * <p>The period of time a signaling channel retains undelivered messages before they are
      *             discarded.</p>
      */
     MessageTtlSeconds?: number;
@@ -159,6 +161,10 @@ export declare class ClientLimitExceededException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<ClientLimitExceededException, __BaseException>);
 }
+export declare enum ConfigurationStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
 /**
  * <p>A key and value pair that is associated with the specified signaling channel.</p>
  */
@@ -180,8 +186,7 @@ export declare namespace Tag {
 }
 export interface CreateSignalingChannelInput {
     /**
-     * <p>A name for the signaling channel that you are creating. It must be unique for each AWS
-     *             account and AWS Region.</p>
+     * <p>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.</p>
      */
     ChannelName: string | undefined;
     /**
@@ -230,7 +235,12 @@ export declare class InvalidArgumentException extends __BaseException {
     constructor(opts: __ExceptionOptionType<InvalidArgumentException, __BaseException>);
 }
 /**
- * <p>The signaling channel is currently not available for this operation.</p>
+ * <p>The resource is currently not available for this operation. New resources cannot be
+ *             created with the same name as existing resources. Also, resources cannot be updated or
+ *             deleted unless they are in an <code>ACTIVE</code> state.</p>
+ *         <p>If this exception is returned, do not use it to determine whether the requested
+ *             resource already exists. Instead, it is recommended you use the resource-specific
+ *             describe API, for example, <code>DescribeStream</code> for video streams.</p>
  */
 export declare class ResourceInUseException extends __BaseException {
     readonly name: "ResourceInUseException";
@@ -243,7 +253,7 @@ export declare class ResourceInUseException extends __BaseException {
 }
 /**
  * <p>You have exceeded the limit of tags that you can associate with the resource.
- *             Kinesis video streams support up to 50 tags. </p>
+ *             A Kinesis video stream can support up to 50 tags. </p>
  */
 export declare class TagsPerResourceExceededLimitException extends __BaseException {
     readonly name: "TagsPerResourceExceededLimitException";
@@ -281,7 +291,7 @@ export interface CreateStreamInput {
      */
     MediaType?: string;
     /**
-     * <p>The ID of the AWS Key Management Service (AWS KMS) key that you want Kinesis Video
+     * <p>The ID of the Key Management Service (KMS) key that you want Kinesis Video
      *             Streams to use to encrypt stream data.</p>
      *         <p>If no key ID is specified, the default, Kinesis Video-managed key
      *                 (<code>aws/kinesisvideo</code>) is used.</p>
@@ -289,8 +299,7 @@ export interface CreateStreamInput {
      */
     KmsKeyId?: string;
     /**
-     * <p>The number of hours that you want to retain the data in the stream. Kinesis Video
-     *             Streams retains the data in a data store that is associated with the stream.</p>
+     * <p>The number of hours that you want to retain the data in the stream. Kinesis Video Streams retains the data in a data store that is associated with the stream.</p>
      *         <p>The default value is 0, indicating that the stream does not persist data.</p>
      *         <p>When the <code>DataRetentionInHours</code> value is 0, consumers can still consume
      *             the fragments that remain in the service host buffer, which has a retention time limit
@@ -442,6 +451,182 @@ export declare class NotAuthorizedException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<NotAuthorizedException, __BaseException>);
 }
+export interface DescribeImageGenerationConfigurationInput {
+    /**
+     * <p>The name of the stream from which to retrieve the image generation configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.  </p>
+     */
+    StreamName?: string;
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Kinesis video stream from which to retrieve the image generation configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p>
+     */
+    StreamARN?: string;
+}
+export declare namespace DescribeImageGenerationConfigurationInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DescribeImageGenerationConfigurationInput) => any;
+}
+/**
+ * <p>The structure that contains the information required to deliver images to a customer.</p>
+ */
+export interface ImageGenerationDestinationConfig {
+    /**
+     * <p>The Uniform Resource Idenifier (URI) that identifies where the images will be delivered.</p>
+     */
+    Uri: string | undefined;
+    /**
+     * <p>The AWS Region of the S3 bucket where images will be delivered. This <code>DestinationRegion</code> must match the Region where the stream is located.</p>
+     */
+    DestinationRegion: string | undefined;
+}
+export declare namespace ImageGenerationDestinationConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ImageGenerationDestinationConfig) => any;
+}
+export declare enum Format {
+    JPEG = "JPEG",
+    PNG = "PNG"
+}
+export declare enum FormatConfigKey {
+    JPEGQuality = "JPEGQuality"
+}
+export declare enum ImageSelectorType {
+    PRODUCER_TIMESTAMP = "PRODUCER_TIMESTAMP",
+    SERVER_TIMESTAMP = "SERVER_TIMESTAMP"
+}
+/**
+ * <p>The structure that contains the information required for the KVS images delivery. If null, the configuration will be deleted from the stream.</p>
+ */
+export interface ImageGenerationConfiguration {
+    /**
+     * <p>Indicates whether the <code>ContinuousImageGenerationConfigurations</code> API is enabled or disabled.</p>
+     */
+    Status: ConfigurationStatus | string | undefined;
+    /**
+     * <p>The origin of the Server or Producer timestamps to use to generate the images.</p>
+     */
+    ImageSelectorType: ImageSelectorType | string | undefined;
+    /**
+     * <p>The structure that contains the information required to deliver images to a customer.</p>
+     */
+    DestinationConfig: ImageGenerationDestinationConfig | undefined;
+    /**
+     * <p>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 <code>StartTimestamp</code> will be returned if available. </p>
+     */
+    SamplingInterval: number | undefined;
+    /**
+     * <p>The accepted image format.</p>
+     */
+    Format: Format | string | undefined;
+    /**
+     * <p>The list of a key-value pair structure that contains extra parameters that can be applied when the image is generated.
+     *             The <code>FormatConfig</code> key is the <code>JPEGQuality</code>, which indicates the JPEG quality key to be used to generate the image.
+     *             The <code>FormatConfig</code> 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 <code>JPEGQuality</code>
+     *             key will be set to 80.</p>
+     */
+    FormatConfig?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The width of the output image that is used in conjunction with the <code>HeightPixels</code> parameter. When both <code>WidthPixels</code> and
+     *             <code>HeightPixels</code> parameters are provided, the image will be stretched to fit the specified aspect ratio. If only the <code>WidthPixels</code> parameter is
+     *             provided, its original aspect ratio will be used to calculate the <code>HeightPixels</code> ratio. If neither parameter is provided, the original image size will be returned.</p>
+     */
+    WidthPixels?: number;
+    /**
+     * <p>The height of the output image that is used in conjunction with the <code>WidthPixels</code> parameter. When both
+     *             <code>HeightPixels</code> and <code>WidthPixels</code> parameters are provided, the image will be stretched to fit the specified aspect ratio.
+     *             If only the <code>HeightPixels</code> parameter is provided, its original aspect ratio will be used to calculate the <code>WidthPixels</code> ratio.
+     *             If neither parameter is provided, the original image size will be returned.</p>
+     */
+    HeightPixels?: number;
+}
+export declare namespace ImageGenerationConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ImageGenerationConfiguration) => any;
+}
+export interface DescribeImageGenerationConfigurationOutput {
+    /**
+     * <p>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.</p>
+     */
+    ImageGenerationConfiguration?: ImageGenerationConfiguration;
+}
+export declare namespace DescribeImageGenerationConfigurationOutput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DescribeImageGenerationConfigurationOutput) => any;
+}
+export interface DescribeNotificationConfigurationInput {
+    /**
+     * <p>The name of the stream from which to retrieve the notification configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p>
+     */
+    StreamName?: string;
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to retrieve the notification configuration. You must specify either the <code>StreamName</code> or the StreamARN.</p>
+     */
+    StreamARN?: string;
+}
+export declare namespace DescribeNotificationConfigurationInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DescribeNotificationConfigurationInput) => any;
+}
+/**
+ * <p>The structure that contains the information required to deliver a notification to a customer.</p>
+ */
+export interface NotificationDestinationConfig {
+    /**
+     * <p>The Uniform Resource Idenifier (URI) that identifies where the images will be delivered.</p>
+     */
+    Uri: string | undefined;
+}
+export declare namespace NotificationDestinationConfig {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: NotificationDestinationConfig) => any;
+}
+/**
+ * <p>The structure that contains the notification information for the KVS images delivery. If this parameter is null, the configuration will be deleted from the stream.</p>
+ */
+export interface NotificationConfiguration {
+    /**
+     * <p>Indicates if a notification configuration is enabled or disabled.</p>
+     */
+    Status: ConfigurationStatus | string | undefined;
+    /**
+     * <p>The destination information required to deliver a notification to a customer.</p>
+     */
+    DestinationConfig: NotificationDestinationConfig | undefined;
+}
+export declare namespace NotificationConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: NotificationConfiguration) => any;
+}
+export interface DescribeNotificationConfigurationOutput {
+    /**
+     * <p>The structure that contains the information required for notifications. If the structure is null, the configuration will be deleted from the stream.</p>
+     */
+    NotificationConfiguration?: NotificationConfiguration;
+}
+export declare namespace DescribeNotificationConfigurationOutput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DescribeNotificationConfigurationOutput) => any;
+}
 export interface DescribeSignalingChannelInput {
     /**
      * <p>The name of the signaling channel that you want to describe.</p>
@@ -508,7 +693,7 @@ export interface StreamInfo {
      */
     MediaType?: string;
     /**
-     * <p>The ID of the AWS Key Management Service (AWS KMS) key that Kinesis Video Streams
+     * <p>The ID of the Key Management Service (KMS) key that Kinesis Video Streams
      *             uses to encrypt data on the stream.</p>
      */
     KmsKeyId?: string;
@@ -1016,6 +1201,75 @@ export declare namespace UpdateDataRetentionOutput {
      */
     const filterSensitiveLog: (obj: UpdateDataRetentionOutput) => any;
 }
+/**
+ * <p>The Stream data retention in hours is equal to zero.</p>
+ */
+export declare class NoDataRetentionException extends __BaseException {
+    readonly name: "NoDataRetentionException";
+    readonly $fault: "client";
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NoDataRetentionException, __BaseException>);
+}
+export interface UpdateImageGenerationConfigurationInput {
+    /**
+     * <p>The name of the stream from which to update the image generation configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p>
+     */
+    StreamName?: string;
+    /**
+     * <p>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 <code>StreamName</code>
+     *             or the <code>StreamARN</code>.</p>
+     */
+    StreamARN?: string;
+    /**
+     * <p>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.</p>
+     */
+    ImageGenerationConfiguration?: ImageGenerationConfiguration;
+}
+export declare namespace UpdateImageGenerationConfigurationInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateImageGenerationConfigurationInput) => any;
+}
+export interface UpdateImageGenerationConfigurationOutput {
+}
+export declare namespace UpdateImageGenerationConfigurationOutput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateImageGenerationConfigurationOutput) => any;
+}
+export interface UpdateNotificationConfigurationInput {
+    /**
+     * <p>The name of the stream from which to update the notification configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p>
+     */
+    StreamName?: string;
+    /**
+     * <p>The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to update the notification configuration. You must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p>
+     */
+    StreamARN?: string;
+    /**
+     * <p>The structure containing the information required for notifications. If the structure is null, the configuration will be deleted from the stream.</p>
+     */
+    NotificationConfiguration?: NotificationConfiguration;
+}
+export declare namespace UpdateNotificationConfigurationInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateNotificationConfigurationInput) => any;
+}
+export interface UpdateNotificationConfigurationOutput {
+}
+export declare namespace UpdateNotificationConfigurationOutput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateNotificationConfigurationOutput) => any;
+}
 export interface UpdateSignalingChannelInput {
     /**
      * <p>The Amazon Resource Name (ARN) of the signaling channel that you want to