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

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { __assign, __awaiter, __generator, __read } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, } from "@aws-sdk/smithy-client";
 import { KinesisVideoServiceException as __BaseException } from "../models/KinesisVideoServiceException";
-import { AccessDeniedException, AccountChannelLimitExceededException, AccountStreamLimitExceededException, ClientLimitExceededException, DeviceStreamLimitExceededException, InvalidArgumentException, InvalidDeviceException, InvalidResourceFormatException, NotAuthorizedException, ResourceInUseException, ResourceNotFoundException, TagsPerResourceExceededLimitException, VersionMismatchException, } from "../models/models_0";
+import { AccessDeniedException, AccountChannelLimitExceededException, AccountStreamLimitExceededException, ClientLimitExceededException, DeviceStreamLimitExceededException, InvalidArgumentException, InvalidDeviceException, InvalidResourceFormatException, NoDataRetentionException, NotAuthorizedException, ResourceInUseException, ResourceNotFoundException, TagsPerResourceExceededLimitException, VersionMismatchException, } from "../models/models_0";
 export var serializeAws_restJson1CreateSignalingChannelCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
     return __generator(this, function (_c) {
@@ -107,6 +107,54 @@ export var serializeAws_restJson1DeleteStreamCommand = function (input, context)
         }
     });
 }); };
+export var serializeAws_restJson1DescribeImageGenerationConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/describeImageGenerationConfiguration";
+                body = JSON.stringify(__assign(__assign({}, (input.StreamARN !== undefined && input.StreamARN !== null && { StreamARN: input.StreamARN })), (input.StreamName !== undefined && input.StreamName !== null && { StreamName: input.StreamName })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
+export var serializeAws_restJson1DescribeNotificationConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/describeNotificationConfiguration";
+                body = JSON.stringify(__assign(__assign({}, (input.StreamARN !== undefined && input.StreamARN !== null && { StreamARN: input.StreamARN })), (input.StreamName !== undefined && input.StreamName !== null && { StreamName: input.StreamName })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
 export var serializeAws_restJson1DescribeSignalingChannelCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
     return __generator(this, function (_c) {
@@ -434,6 +482,60 @@ export var serializeAws_restJson1UpdateDataRetentionCommand = function (input, c
         }
     });
 }); };
+export var serializeAws_restJson1UpdateImageGenerationConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/updateImageGenerationConfiguration";
+                body = JSON.stringify(__assign(__assign(__assign({}, (input.ImageGenerationConfiguration !== undefined &&
+                    input.ImageGenerationConfiguration !== null && {
+                    ImageGenerationConfiguration: serializeAws_restJson1ImageGenerationConfiguration(input.ImageGenerationConfiguration, context),
+                })), (input.StreamARN !== undefined && input.StreamARN !== null && { StreamARN: input.StreamARN })), (input.StreamName !== undefined && input.StreamName !== null && { StreamName: input.StreamName })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
+export var serializeAws_restJson1UpdateNotificationConfigurationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/updateNotificationConfiguration";
+                body = JSON.stringify(__assign(__assign(__assign({}, (input.NotificationConfiguration !== undefined &&
+                    input.NotificationConfiguration !== null && {
+                    NotificationConfiguration: serializeAws_restJson1NotificationConfiguration(input.NotificationConfiguration, context),
+                })), (input.StreamARN !== undefined && input.StreamARN !== null && { StreamARN: input.StreamARN })), (input.StreamName !== undefined && input.StreamName !== null && { StreamName: input.StreamName })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
 export var serializeAws_restJson1UpdateSignalingChannelCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
     return __generator(this, function (_c) {
@@ -783,6 +885,142 @@ var deserializeAws_restJson1DeleteStreamCommandError = function (output, context
         }
     });
 }); };
+export var deserializeAws_restJson1DescribeImageGenerationConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1DescribeImageGenerationConfigurationCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                    ImageGenerationConfiguration: undefined,
+                };
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.ImageGenerationConfiguration !== undefined && data.ImageGenerationConfiguration !== null) {
+                    contents.ImageGenerationConfiguration = deserializeAws_restJson1ImageGenerationConfiguration(data.ImageGenerationConfiguration, context);
+                }
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1DescribeImageGenerationConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.kinesisvideo#AccessDeniedException": return [3, 2];
+                    case "ClientLimitExceededException": return [3, 4];
+                    case "com.amazonaws.kinesisvideo#ClientLimitExceededException": return [3, 4];
+                    case "InvalidArgumentException": return [3, 6];
+                    case "com.amazonaws.kinesisvideo#InvalidArgumentException": return [3, 6];
+                    case "ResourceNotFoundException": return [3, 8];
+                    case "com.amazonaws.kinesisvideo#ResourceNotFoundException": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ClientLimitExceededExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1InvalidArgumentExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
+export var deserializeAws_restJson1DescribeNotificationConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1DescribeNotificationConfigurationCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                    NotificationConfiguration: undefined,
+                };
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.NotificationConfiguration !== undefined && data.NotificationConfiguration !== null) {
+                    contents.NotificationConfiguration = deserializeAws_restJson1NotificationConfiguration(data.NotificationConfiguration, context);
+                }
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1DescribeNotificationConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.kinesisvideo#AccessDeniedException": return [3, 2];
+                    case "ClientLimitExceededException": return [3, 4];
+                    case "com.amazonaws.kinesisvideo#ClientLimitExceededException": return [3, 4];
+                    case "InvalidArgumentException": return [3, 6];
+                    case "com.amazonaws.kinesisvideo#InvalidArgumentException": return [3, 6];
+                    case "ResourceNotFoundException": return [3, 8];
+                    case "com.amazonaws.kinesisvideo#ResourceNotFoundException": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ClientLimitExceededExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1InvalidArgumentExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_restJson1DescribeSignalingChannelCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, _a, _b;
     return __generator(this, function (_c) {
@@ -1673,6 +1911,146 @@ var deserializeAws_restJson1UpdateDataRetentionCommandError = function (output,
         }
     });
 }); };
+export var deserializeAws_restJson1UpdateImageGenerationConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1UpdateImageGenerationConfigurationCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1UpdateImageGenerationConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.kinesisvideo#AccessDeniedException": return [3, 2];
+                    case "ClientLimitExceededException": return [3, 4];
+                    case "com.amazonaws.kinesisvideo#ClientLimitExceededException": return [3, 4];
+                    case "InvalidArgumentException": return [3, 6];
+                    case "com.amazonaws.kinesisvideo#InvalidArgumentException": return [3, 6];
+                    case "NoDataRetentionException": return [3, 8];
+                    case "com.amazonaws.kinesisvideo#NoDataRetentionException": return [3, 8];
+                    case "ResourceInUseException": return [3, 10];
+                    case "com.amazonaws.kinesisvideo#ResourceInUseException": return [3, 10];
+                    case "ResourceNotFoundException": return [3, 12];
+                    case "com.amazonaws.kinesisvideo#ResourceNotFoundException": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ClientLimitExceededExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1InvalidArgumentExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1NoDataRetentionExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
+export var deserializeAws_restJson1UpdateNotificationConfigurationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1UpdateNotificationConfigurationCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1UpdateNotificationConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "AccessDeniedException": return [3, 2];
+                    case "com.amazonaws.kinesisvideo#AccessDeniedException": return [3, 2];
+                    case "ClientLimitExceededException": return [3, 4];
+                    case "com.amazonaws.kinesisvideo#ClientLimitExceededException": return [3, 4];
+                    case "InvalidArgumentException": return [3, 6];
+                    case "com.amazonaws.kinesisvideo#InvalidArgumentException": return [3, 6];
+                    case "NoDataRetentionException": return [3, 8];
+                    case "com.amazonaws.kinesisvideo#NoDataRetentionException": return [3, 8];
+                    case "ResourceInUseException": return [3, 10];
+                    case "com.amazonaws.kinesisvideo#ResourceInUseException": return [3, 10];
+                    case "ResourceNotFoundException": return [3, 12];
+                    case "com.amazonaws.kinesisvideo#ResourceNotFoundException": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ClientLimitExceededExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1InvalidArgumentExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1NoDataRetentionExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_restJson1ResourceInUseExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_restJson1UpdateSignalingChannelCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents;
     return __generator(this, function (_a) {
@@ -1909,6 +2287,18 @@ var deserializeAws_restJson1InvalidResourceFormatExceptionResponse = function (p
         return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
+var deserializeAws_restJson1NoDataRetentionExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
+        }
+        exception = new NoDataRetentionException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
 var deserializeAws_restJson1NotAuthorizedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, exception;
     return __generator(this, function (_a) {
@@ -1974,6 +2364,29 @@ var serializeAws_restJson1ChannelNameCondition = function (input, context) {
         input.ComparisonOperator !== null && { ComparisonOperator: input.ComparisonOperator })), (input.ComparisonValue !== undefined &&
         input.ComparisonValue !== null && { ComparisonValue: input.ComparisonValue }));
 };
+var serializeAws_restJson1FormatConfig = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        if (value === null) {
+            return acc;
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b));
+    }, {});
+};
+var serializeAws_restJson1ImageGenerationConfiguration = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.DestinationConfig !== undefined &&
+        input.DestinationConfig !== null && {
+        DestinationConfig: serializeAws_restJson1ImageGenerationDestinationConfig(input.DestinationConfig, context),
+    })), (input.Format !== undefined && input.Format !== null && { Format: input.Format })), (input.FormatConfig !== undefined &&
+        input.FormatConfig !== null && { FormatConfig: serializeAws_restJson1FormatConfig(input.FormatConfig, context) })), (input.HeightPixels !== undefined && input.HeightPixels !== null && { HeightPixels: input.HeightPixels })), (input.ImageSelectorType !== undefined &&
+        input.ImageSelectorType !== null && { ImageSelectorType: input.ImageSelectorType })), (input.SamplingInterval !== undefined &&
+        input.SamplingInterval !== null && { SamplingInterval: input.SamplingInterval })), (input.Status !== undefined && input.Status !== null && { Status: input.Status })), (input.WidthPixels !== undefined && input.WidthPixels !== null && { WidthPixels: input.WidthPixels }));
+};
+var serializeAws_restJson1ImageGenerationDestinationConfig = function (input, context) {
+    return __assign(__assign({}, (input.DestinationRegion !== undefined &&
+        input.DestinationRegion !== null && { DestinationRegion: input.DestinationRegion })), (input.Uri !== undefined && input.Uri !== null && { Uri: input.Uri }));
+};
 var serializeAws_restJson1ListOfProtocols = function (input, context) {
     return input
         .filter(function (e) { return e != null; })
@@ -1984,6 +2397,15 @@ var serializeAws_restJson1ListOfProtocols = function (input, context) {
         return entry;
     });
 };
+var serializeAws_restJson1NotificationConfiguration = function (input, context) {
+    return __assign(__assign({}, (input.DestinationConfig !== undefined &&
+        input.DestinationConfig !== null && {
+        DestinationConfig: serializeAws_restJson1NotificationDestinationConfig(input.DestinationConfig, context),
+    })), (input.Status !== undefined && input.Status !== null && { Status: input.Status }));
+};
+var serializeAws_restJson1NotificationDestinationConfig = function (input, context) {
+    return __assign({}, (input.Uri !== undefined && input.Uri !== null && { Uri: input.Uri }));
+};
 var serializeAws_restJson1ResourceTags = function (input, context) {
     return Object.entries(input).reduce(function (acc, _a) {
         var _b;
@@ -2066,6 +2488,51 @@ var deserializeAws_restJson1ChannelInfoList = function (output, context) {
     });
     return retVal;
 };
+var deserializeAws_restJson1FormatConfig = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        if (value === null) {
+            return acc;
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
+    }, {});
+};
+var deserializeAws_restJson1ImageGenerationConfiguration = function (output, context) {
+    return {
+        DestinationConfig: output.DestinationConfig !== undefined && output.DestinationConfig !== null
+            ? deserializeAws_restJson1ImageGenerationDestinationConfig(output.DestinationConfig, context)
+            : undefined,
+        Format: __expectString(output.Format),
+        FormatConfig: output.FormatConfig !== undefined && output.FormatConfig !== null
+            ? deserializeAws_restJson1FormatConfig(output.FormatConfig, context)
+            : undefined,
+        HeightPixels: __expectInt32(output.HeightPixels),
+        ImageSelectorType: __expectString(output.ImageSelectorType),
+        SamplingInterval: __expectInt32(output.SamplingInterval),
+        Status: __expectString(output.Status),
+        WidthPixels: __expectInt32(output.WidthPixels),
+    };
+};
+var deserializeAws_restJson1ImageGenerationDestinationConfig = function (output, context) {
+    return {
+        DestinationRegion: __expectString(output.DestinationRegion),
+        Uri: __expectString(output.Uri),
+    };
+};
+var deserializeAws_restJson1NotificationConfiguration = function (output, context) {
+    return {
+        DestinationConfig: output.DestinationConfig !== undefined && output.DestinationConfig !== null
+            ? deserializeAws_restJson1NotificationDestinationConfig(output.DestinationConfig, context)
+            : undefined,
+        Status: __expectString(output.Status),
+    };
+};
+var deserializeAws_restJson1NotificationDestinationConfig = function (output, context) {
+    return {
+        Uri: __expectString(output.Uri),
+    };
+};
 var deserializeAws_restJson1ResourceEndpointList = function (output, context) {
     var retVal = (output || [])
         .filter(function (e) { return e != null; })

package/dist-types/KinesisVideo.d.ts

@@ -3,6 +3,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";
@@ -16,6 +18,8 @@ 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";
 import { KinesisVideoClient } from "./KinesisVideoClient";
@@ -68,6 +72,18 @@ export declare class KinesisVideo extends KinesisVideoClient {
     deleteStream(args: DeleteStreamCommandInput, options?: __HttpHandlerOptions): Promise<DeleteStreamCommandOutput>;
     deleteStream(args: DeleteStreamCommandInput, cb: (err: any, data?: DeleteStreamCommandOutput) => void): void;
     deleteStream(args: DeleteStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteStreamCommandOutput) => void): void;
+    /**
+     * <p>Gets the <code>ImageGenerationConfiguration</code> for a given Kinesis video stream.</p>
+     */
+    describeImageGenerationConfiguration(args: DescribeImageGenerationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DescribeImageGenerationConfigurationCommandOutput>;
+    describeImageGenerationConfiguration(args: DescribeImageGenerationConfigurationCommandInput, cb: (err: any, data?: DescribeImageGenerationConfigurationCommandOutput) => void): void;
+    describeImageGenerationConfiguration(args: DescribeImageGenerationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeImageGenerationConfigurationCommandOutput) => void): void;
+    /**
+     * <p>Gets the <code>NotificationConfiguration</code> for a given Kinesis video stream.</p>
+     */
+    describeNotificationConfiguration(args: DescribeNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DescribeNotificationConfigurationCommandOutput>;
+    describeNotificationConfiguration(args: DescribeNotificationConfigurationCommandInput, cb: (err: any, data?: DescribeNotificationConfigurationCommandOutput) => void): void;
+    describeNotificationConfiguration(args: DescribeNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeNotificationConfigurationCommandOutput) => void): void;
     /**
      * <p>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
@@ -113,16 +129,16 @@ export declare class KinesisVideo extends KinesisVideoClient {
      *             <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>
      */
     getSignalingChannelEndpoint(args: GetSignalingChannelEndpointCommandInput, options?: __HttpHandlerOptions): Promise<GetSignalingChannelEndpointCommandOutput>;
     getSignalingChannelEndpoint(args: GetSignalingChannelEndpointCommandInput, cb: (err: any, data?: GetSignalingChannelEndpointCommandOutput) => void): void;
     getSignalingChannelEndpoint(args: GetSignalingChannelEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSignalingChannelEndpointCommandOutput) => void): void;
     /**
      * <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>
      */
     listSignalingChannels(args: ListSignalingChannelsCommandInput, options?: __HttpHandlerOptions): Promise<ListSignalingChannelsCommandOutput>;
     listSignalingChannels(args: ListSignalingChannelsCommandInput, cb: (err: any, data?: ListSignalingChannelsCommandOutput) => void): void;
@@ -151,10 +167,10 @@ export declare class KinesisVideo extends KinesisVideoClient {
     listTagsForStream(args: ListTagsForStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForStreamCommandOutput) => void): void;
     /**
      * <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>
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
@@ -162,15 +178,15 @@ export declare class KinesisVideo extends KinesisVideoClient {
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     /**
      * <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>
      */
     tagStream(args: TagStreamCommandInput, options?: __HttpHandlerOptions): Promise<TagStreamCommandOutput>;
     tagStream(args: TagStreamCommandInput, cb: (err: any, data?: TagStreamCommandOutput) => void): void;
@@ -225,6 +241,18 @@ export declare class KinesisVideo extends KinesisVideoClient {
     updateDataRetention(args: UpdateDataRetentionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDataRetentionCommandOutput>;
     updateDataRetention(args: UpdateDataRetentionCommandInput, cb: (err: any, data?: UpdateDataRetentionCommandOutput) => void): void;
     updateDataRetention(args: UpdateDataRetentionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDataRetentionCommandOutput) => void): void;
+    /**
+     * <p>Updates the <code>StreamInfo</code> and <code>ImageProcessingConfiguration</code> fields.</p>
+     */
+    updateImageGenerationConfiguration(args: UpdateImageGenerationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateImageGenerationConfigurationCommandOutput>;
+    updateImageGenerationConfiguration(args: UpdateImageGenerationConfigurationCommandInput, cb: (err: any, data?: UpdateImageGenerationConfigurationCommandOutput) => void): void;
+    updateImageGenerationConfiguration(args: UpdateImageGenerationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateImageGenerationConfigurationCommandOutput) => void): void;
+    /**
+     * <p>Updates the notification information for a stream.</p>
+     */
+    updateNotificationConfiguration(args: UpdateNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateNotificationConfigurationCommandOutput>;
+    updateNotificationConfiguration(args: UpdateNotificationConfigurationCommandInput, cb: (err: any, data?: UpdateNotificationConfigurationCommandOutput) => void): void;
+    updateNotificationConfiguration(args: UpdateNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateNotificationConfigurationCommandOutput) => void): void;
     /**
      * <p>Updates the existing signaling channel. This is an asynchronous operation and takes
      *             time to complete. </p>