@aws-sdk/client-kinesis-video 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class KinesisVideoClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class KinesisVideoClient extends smithyClient.Client {
     }
 }
 
-class KinesisVideoServiceException extends smithyClient.ServiceException {
+let KinesisVideoServiceException$1 = class KinesisVideoServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, KinesisVideoServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends KinesisVideoServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends KinesisVideoServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -130,8 +130,8 @@ class AccessDeniedException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
-class AccountChannelLimitExceededException extends KinesisVideoServiceException {
+};
+let AccountChannelLimitExceededException$1 = class AccountChannelLimitExceededException extends KinesisVideoServiceException$1 {
     name = "AccountChannelLimitExceededException";
     $fault = "client";
     Message;
@@ -144,8 +144,8 @@ class AccountChannelLimitExceededException extends KinesisVideoServiceException
         Object.setPrototypeOf(this, AccountChannelLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class AccountStreamLimitExceededException extends KinesisVideoServiceException {
+};
+let AccountStreamLimitExceededException$1 = class AccountStreamLimitExceededException extends KinesisVideoServiceException$1 {
     name = "AccountStreamLimitExceededException";
     $fault = "client";
     Message;
@@ -158,7 +158,7 @@ class AccountStreamLimitExceededException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, AccountStreamLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const APIName = {
     GET_CLIP: "GET_CLIP",
     GET_DASH_STREAMING_SESSION_URL: "GET_DASH_STREAMING_SESSION_URL",
@@ -191,7 +191,7 @@ const ChannelRole = {
     MASTER: "MASTER",
     VIEWER: "VIEWER",
 };
-class ClientLimitExceededException extends KinesisVideoServiceException {
+let ClientLimitExceededException$1 = class ClientLimitExceededException extends KinesisVideoServiceException$1 {
     name = "ClientLimitExceededException";
     $fault = "client";
     Message;
@@ -204,12 +204,12 @@ class ClientLimitExceededException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, ClientLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ConfigurationStatus = {
     DISABLED: "DISABLED",
     ENABLED: "ENABLED",
 };
-class InvalidArgumentException extends KinesisVideoServiceException {
+let InvalidArgumentException$1 = class InvalidArgumentException extends KinesisVideoServiceException$1 {
     name = "InvalidArgumentException";
     $fault = "client";
     Message;
@@ -222,8 +222,8 @@ class InvalidArgumentException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, InvalidArgumentException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceInUseException extends KinesisVideoServiceException {
+};
+let ResourceInUseException$1 = class ResourceInUseException extends KinesisVideoServiceException$1 {
     name = "ResourceInUseException";
     $fault = "client";
     Message;
@@ -236,8 +236,8 @@ class ResourceInUseException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
         this.Message = opts.Message;
     }
-}
-class TagsPerResourceExceededLimitException extends KinesisVideoServiceException {
+};
+let TagsPerResourceExceededLimitException$1 = class TagsPerResourceExceededLimitException extends KinesisVideoServiceException$1 {
     name = "TagsPerResourceExceededLimitException";
     $fault = "client";
     Message;
@@ -250,8 +250,8 @@ class TagsPerResourceExceededLimitException extends KinesisVideoServiceException
         Object.setPrototypeOf(this, TagsPerResourceExceededLimitException.prototype);
         this.Message = opts.Message;
     }
-}
-class DeviceStreamLimitExceededException extends KinesisVideoServiceException {
+};
+let DeviceStreamLimitExceededException$1 = class DeviceStreamLimitExceededException extends KinesisVideoServiceException$1 {
     name = "DeviceStreamLimitExceededException";
     $fault = "client";
     Message;
@@ -264,8 +264,8 @@ class DeviceStreamLimitExceededException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, DeviceStreamLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidDeviceException extends KinesisVideoServiceException {
+};
+let InvalidDeviceException$1 = class InvalidDeviceException extends KinesisVideoServiceException$1 {
     name = "InvalidDeviceException";
     $fault = "client";
     Message;
@@ -278,8 +278,8 @@ class InvalidDeviceException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, InvalidDeviceException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends KinesisVideoServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends KinesisVideoServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -292,8 +292,8 @@ class ResourceNotFoundException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class StreamEdgeConfigurationNotFoundException extends KinesisVideoServiceException {
+};
+let StreamEdgeConfigurationNotFoundException$1 = class StreamEdgeConfigurationNotFoundException extends KinesisVideoServiceException$1 {
     name = "StreamEdgeConfigurationNotFoundException";
     $fault = "client";
     Message;
@@ -306,8 +306,8 @@ class StreamEdgeConfigurationNotFoundException extends KinesisVideoServiceExcept
         Object.setPrototypeOf(this, StreamEdgeConfigurationNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class VersionMismatchException extends KinesisVideoServiceException {
+};
+let VersionMismatchException$1 = class VersionMismatchException extends KinesisVideoServiceException$1 {
     name = "VersionMismatchException";
     $fault = "client";
     Message;
@@ -320,8 +320,8 @@ class VersionMismatchException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, VersionMismatchException.prototype);
         this.Message = opts.Message;
     }
-}
-class NotAuthorizedException extends KinesisVideoServiceException {
+};
+let NotAuthorizedException$1 = class NotAuthorizedException extends KinesisVideoServiceException$1 {
     name = "NotAuthorizedException";
     $fault = "client";
     Message;
@@ -334,7 +334,7 @@ class NotAuthorizedException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, NotAuthorizedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const StrategyOnFullSize = {
     DELETE_OLDEST_MEDIA: "DELETE_OLDEST_MEDIA",
     DENY_NEW_MEDIA: "DENY_NEW_MEDIA",
@@ -377,7 +377,7 @@ const MediaStorageConfigurationStatus = {
     DISABLED: "DISABLED",
     ENABLED: "ENABLED",
 };
-class InvalidResourceFormatException extends KinesisVideoServiceException {
+let InvalidResourceFormatException$1 = class InvalidResourceFormatException extends KinesisVideoServiceException$1 {
     name = "InvalidResourceFormatException";
     $fault = "client";
     Message;
@@ -390,8 +390,8 @@ class InvalidResourceFormatException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, InvalidResourceFormatException.prototype);
         this.Message = opts.Message;
     }
-}
-class NoDataRetentionException extends KinesisVideoServiceException {
+};
+let NoDataRetentionException$1 = class NoDataRetentionException extends KinesisVideoServiceException$1 {
     name = "NoDataRetentionException";
     $fault = "client";
     Message;
@@ -404,1237 +404,1023 @@ class NoDataRetentionException extends KinesisVideoServiceException {
         Object.setPrototypeOf(this, NoDataRetentionException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const UpdateDataRetentionOperation = {
     DECREASE_DATA_RETENTION: "DECREASE_DATA_RETENTION",
     INCREASE_DATA_RETENTION: "INCREASE_DATA_RETENTION",
 };
-const MediaSourceConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.MediaUriSecretArn && { MediaUriSecretArn: smithyClient.SENSITIVE_STRING }),
-});
-const RecorderConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.MediaSourceConfig && { MediaSourceConfig: MediaSourceConfigFilterSensitiveLog(obj.MediaSourceConfig) }),
-});
-const EdgeConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RecorderConfig && { RecorderConfig: RecorderConfigFilterSensitiveLog(obj.RecorderConfig) }),
-});
-const DescribeEdgeConfigurationOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }),
-});
-const ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }),
-});
-const ListEdgeAgentConfigurationsOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EdgeConfigs && {
-        EdgeConfigs: obj.EdgeConfigs.map((item) => ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog(item)),
-    }),
-});
-const StartEdgeConfigurationUpdateInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }),
-});
-const StartEdgeConfigurationUpdateOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EdgeConfig && { EdgeConfig: EdgeConfigFilterSensitiveLog(obj.EdgeConfig) }),
-});
 
-const se_CreateSignalingChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/createSignalingChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelName: [],
-        ChannelType: [],
-        SingleMasterConfiguration: (_) => smithyClient._json(_),
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/createStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        DataRetentionInHours: [],
-        DeviceName: [],
-        KmsKeyId: [],
-        MediaType: [],
-        StreamName: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteEdgeConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/deleteEdgeConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteSignalingChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/deleteSignalingChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        CurrentVersion: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/deleteStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        CurrentVersion: [],
-        StreamARN: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeEdgeConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeEdgeConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeImageGenerationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeImageGenerationConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeMappedResourceConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeMappedResourceConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeMediaStorageConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeMediaStorageConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        ChannelName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeNotificationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeNotificationConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeSignalingChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeSignalingChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        ChannelName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataEndpointCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getDataEndpoint");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        APIName: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSignalingChannelEndpointCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/getSignalingChannelEndpoint");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        SingleMasterChannelEndpointConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListEdgeAgentConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listEdgeAgentConfigurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        HubDeviceArn: [],
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListSignalingChannelsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listSignalingChannels");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelNameCondition: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListStreamsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listStreams");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        StreamNameCondition: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        ResourceARN: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listTagsForStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartEdgeConfigurationUpdateCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/startEdgeConfigurationUpdate");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EdgeConfig: (_) => smithyClient._json(_),
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TagResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceARN: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tagStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceARN: [],
-        TagKeyList: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/untagStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        StreamARN: [],
-        StreamName: [],
-        TagKeyList: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateDataRetentionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateDataRetention");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        CurrentVersion: [],
-        DataRetentionChangeInHours: [],
-        Operation: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateImageGenerationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateImageGenerationConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ImageGenerationConfiguration: (_) => smithyClient._json(_),
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateMediaStorageConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateMediaStorageConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        MediaStorageConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateNotificationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateNotificationConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NotificationConfiguration: (_) => smithyClient._json(_),
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateSignalingChannelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateSignalingChannel");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ChannelARN: [],
-        CurrentVersion: [],
-        SingleMasterConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateStream");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        CurrentVersion: [],
-        DeviceName: [],
-        MediaType: [],
-        StreamARN: [],
-        StreamName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateSignalingChannelCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ChannelARN: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        StreamARN: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteEdgeConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteSignalingChannelCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DescribeEdgeConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        EdgeAgentStatus: (_) => de_EdgeAgentStatus(_),
-        EdgeConfig: smithyClient._json,
-        FailedStatusDetails: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamARN: smithyClient.expectString,
-        StreamName: smithyClient.expectString,
-        SyncStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeImageGenerationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ImageGenerationConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeMappedResourceConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        MappedResourceConfigurationList: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeMediaStorageConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        MediaStorageConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeNotificationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NotificationConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeSignalingChannelCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ChannelInfo: (_) => de_ChannelInfo(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        StreamInfo: (_) => de_StreamInfo(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataEndpointCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        DataEndpoint: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSignalingChannelEndpointCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ResourceEndpointList: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEdgeAgentConfigurationsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        EdgeConfigs: (_) => de_ListEdgeAgentConfigurationsEdgeConfigList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSignalingChannelsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ChannelInfoList: (_) => de_ChannelInfoList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListStreamsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        StreamInfoList: (_) => de_StreamInfoList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartEdgeConfigurationUpdateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        EdgeConfig: smithyClient._json,
-        FailedStatusDetails: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamARN: smithyClient.expectString,
-        StreamName: smithyClient.expectString,
-        SyncStatus: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateDataRetentionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateImageGenerationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateMediaStorageConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateNotificationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateSignalingChannelCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.kinesisvideo#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "AccountChannelLimitExceededException":
-        case "com.amazonaws.kinesisvideo#AccountChannelLimitExceededException":
-            throw await de_AccountChannelLimitExceededExceptionRes(parsedOutput);
-        case "ClientLimitExceededException":
-        case "com.amazonaws.kinesisvideo#ClientLimitExceededException":
-            throw await de_ClientLimitExceededExceptionRes(parsedOutput);
-        case "InvalidArgumentException":
-        case "com.amazonaws.kinesisvideo#InvalidArgumentException":
-            throw await de_InvalidArgumentExceptionRes(parsedOutput);
-        case "ResourceInUseException":
-        case "com.amazonaws.kinesisvideo#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput);
-        case "TagsPerResourceExceededLimitException":
-        case "com.amazonaws.kinesisvideo#TagsPerResourceExceededLimitException":
-            throw await de_TagsPerResourceExceededLimitExceptionRes(parsedOutput);
-        case "AccountStreamLimitExceededException":
-        case "com.amazonaws.kinesisvideo#AccountStreamLimitExceededException":
-            throw await de_AccountStreamLimitExceededExceptionRes(parsedOutput);
-        case "DeviceStreamLimitExceededException":
-        case "com.amazonaws.kinesisvideo#DeviceStreamLimitExceededException":
-            throw await de_DeviceStreamLimitExceededExceptionRes(parsedOutput);
-        case "InvalidDeviceException":
-        case "com.amazonaws.kinesisvideo#InvalidDeviceException":
-            throw await de_InvalidDeviceExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.kinesisvideo#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "StreamEdgeConfigurationNotFoundException":
-        case "com.amazonaws.kinesisvideo#StreamEdgeConfigurationNotFoundException":
-            throw await de_StreamEdgeConfigurationNotFoundExceptionRes(parsedOutput);
-        case "VersionMismatchException":
-        case "com.amazonaws.kinesisvideo#VersionMismatchException":
-            throw await de_VersionMismatchExceptionRes(parsedOutput);
-        case "NotAuthorizedException":
-        case "com.amazonaws.kinesisvideo#NotAuthorizedException":
-            throw await de_NotAuthorizedExceptionRes(parsedOutput);
-        case "InvalidResourceFormatException":
-        case "com.amazonaws.kinesisvideo#InvalidResourceFormatException":
-            throw await de_InvalidResourceFormatExceptionRes(parsedOutput);
-        case "NoDataRetentionException":
-        case "com.amazonaws.kinesisvideo#NoDataRetentionException":
-            throw await de_NoDataRetentionExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(KinesisVideoServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_AccountChannelLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccountChannelLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_AccountStreamLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccountStreamLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ClientLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ClientLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DeviceStreamLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new DeviceStreamLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidArgumentException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidDeviceExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidDeviceException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidResourceFormatExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidResourceFormatException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NoDataRetentionExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NoDataRetentionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotAuthorizedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NotAuthorizedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceInUseException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_StreamEdgeConfigurationNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new StreamEdgeConfigurationNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TagsPerResourceExceededLimitExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new TagsPerResourceExceededLimitException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_VersionMismatchExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new VersionMismatchException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ChannelInfo = (output, context) => {
-    return smithyClient.take(output, {
-        ChannelARN: smithyClient.expectString,
-        ChannelName: smithyClient.expectString,
-        ChannelStatus: smithyClient.expectString,
-        ChannelType: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SingleMasterConfiguration: smithyClient._json,
-        Version: smithyClient.expectString,
-    });
-};
-const de_ChannelInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ChannelInfo(entry);
-    });
-    return retVal;
-};
-const de_EdgeAgentStatus = (output, context) => {
-    return smithyClient.take(output, {
-        LastRecorderStatus: (_) => de_LastRecorderStatus(_),
-        LastUploaderStatus: (_) => de_LastUploaderStatus(_),
-    });
-};
-const de_LastRecorderStatus = (output, context) => {
-    return smithyClient.take(output, {
-        JobStatusDetails: smithyClient.expectString,
-        LastCollectedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RecorderStatus: smithyClient.expectString,
-    });
-};
-const de_LastUploaderStatus = (output, context) => {
-    return smithyClient.take(output, {
-        JobStatusDetails: smithyClient.expectString,
-        LastCollectedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        UploaderStatus: smithyClient.expectString,
-    });
-};
-const de_ListEdgeAgentConfigurationsEdgeConfig = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        EdgeConfig: smithyClient._json,
-        FailedStatusDetails: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamARN: smithyClient.expectString,
-        StreamName: smithyClient.expectString,
-        SyncStatus: smithyClient.expectString,
-    });
-};
-const de_ListEdgeAgentConfigurationsEdgeConfigList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ListEdgeAgentConfigurationsEdgeConfig(entry);
-    });
-    return retVal;
-};
-const de_StreamInfo = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DataRetentionInHours: smithyClient.expectInt32,
-        DeviceName: smithyClient.expectString,
-        KmsKeyId: smithyClient.expectString,
-        MediaType: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        StreamARN: smithyClient.expectString,
-        StreamName: smithyClient.expectString,
-        Version: smithyClient.expectString,
-    });
-};
-const de_StreamInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StreamInfo(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _ACLEE = "AccountChannelLimitExceededException";
+const _ADE = "AccessDeniedException";
+const _APIN = "APIName";
+const _ARN = "ARN";
+const _ASLEE = "AccountStreamLimitExceededException";
+const _CARN = "ChannelARN";
+const _CI = "ChannelInfo";
+const _CIL = "ChannelInfoList";
+const _CLEE = "ClientLimitExceededException";
+const _CN = "ChannelName";
+const _CNC = "ChannelNameCondition";
+const _CO = "ComparisonOperator";
+const _CS = "ChannelStatus";
+const _CSC = "CreateSignalingChannel";
+const _CSCI = "CreateSignalingChannelInput";
+const _CSCO = "CreateSignalingChannelOutput";
+const _CSI = "CreateStreamInput";
+const _CSO = "CreateStreamOutput";
+const _CSr = "CreateStream";
+const _CT = "ChannelType";
+const _CTr = "CreationTime";
+const _CV = "ComparisonValue";
+const _CVu = "CurrentVersion";
+const _DAU = "DeleteAfterUpload";
+const _DC = "DeletionConfig";
+const _DCe = "DestinationConfig";
+const _DE = "DataEndpoint";
+const _DEC = "DeleteEdgeConfiguration";
+const _DECI = "DeleteEdgeConfigurationInput";
+const _DECIe = "DescribeEdgeConfigurationInput";
+const _DECO = "DeleteEdgeConfigurationOutput";
+const _DECOe = "DescribeEdgeConfigurationOutput";
+const _DECe = "DescribeEdgeConfiguration";
+const _DIGC = "DescribeImageGenerationConfiguration";
+const _DIGCI = "DescribeImageGenerationConfigurationInput";
+const _DIGCO = "DescribeImageGenerationConfigurationOutput";
+const _DIS = "DurationInSeconds";
+const _DMRC = "DescribeMappedResourceConfiguration";
+const _DMRCI = "DescribeMappedResourceConfigurationInput";
+const _DMRCO = "DescribeMappedResourceConfigurationOutput";
+const _DMSC = "DescribeMediaStorageConfiguration";
+const _DMSCI = "DescribeMediaStorageConfigurationInput";
+const _DMSCO = "DescribeMediaStorageConfigurationOutput";
+const _DN = "DeviceName";
+const _DNC = "DescribeNotificationConfiguration";
+const _DNCI = "DescribeNotificationConfigurationInput";
+const _DNCO = "DescribeNotificationConfigurationOutput";
+const _DR = "DestinationRegion";
+const _DRCIH = "DataRetentionChangeInHours";
+const _DRIH = "DataRetentionInHours";
+const _DS = "DeleteStream";
+const _DSC = "DeleteSignalingChannel";
+const _DSCI = "DeleteSignalingChannelInput";
+const _DSCIe = "DescribeSignalingChannelInput";
+const _DSCO = "DeleteSignalingChannelOutput";
+const _DSCOe = "DescribeSignalingChannelOutput";
+const _DSCe = "DescribeSignalingChannel";
+const _DSI = "DeleteStreamInput";
+const _DSIe = "DescribeStreamInput";
+const _DSLEE = "DeviceStreamLimitExceededException";
+const _DSO = "DeleteStreamOutput";
+const _DSOe = "DescribeStreamOutput";
+const _DSe = "DescribeStream";
+const _EAS = "EdgeAgentStatus";
+const _EC = "EdgeConfig";
+const _ECd = "EdgeConfigs";
+const _ERIH = "EdgeRetentionInHours";
+const _F = "Format";
+const _FC = "FormatConfig";
+const _FSD = "FailedStatusDetails";
+const _GDE = "GetDataEndpoint";
+const _GDEI = "GetDataEndpointInput";
+const _GDEO = "GetDataEndpointOutput";
+const _GSCE = "GetSignalingChannelEndpoint";
+const _GSCEI = "GetSignalingChannelEndpointInput";
+const _GSCEO = "GetSignalingChannelEndpointOutput";
+const _HDA = "HubDeviceArn";
+const _HP = "HeightPixels";
+const _IAE = "InvalidArgumentException";
+const _IDE = "InvalidDeviceException";
+const _IGC = "ImageGenerationConfiguration";
+const _IGDC = "ImageGenerationDestinationConfig";
+const _IRFE = "InvalidResourceFormatException";
+const _IST = "ImageSelectorType";
+const _JSD = "JobStatusDetails";
+const _K = "Key";
+const _KKI = "KmsKeyId";
+const _LCT = "LastCollectedTime";
+const _LEAC = "ListEdgeAgentConfigurations";
+const _LEACEC = "ListEdgeAgentConfigurationsEdgeConfig";
+const _LEACECL = "ListEdgeAgentConfigurationsEdgeConfigList";
+const _LEACI = "ListEdgeAgentConfigurationsInput";
+const _LEACO = "ListEdgeAgentConfigurationsOutput";
+const _LRS = "LastRecorderStatus";
+const _LS = "ListStreams";
+const _LSC = "LocalSizeConfig";
+const _LSCI = "ListSignalingChannelsInput";
+const _LSCO = "ListSignalingChannelsOutput";
+const _LSCi = "ListSignalingChannels";
+const _LSI = "ListStreamsInput";
+const _LSO = "ListStreamsOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LTFS = "ListTagsForStream";
+const _LTFSI = "ListTagsForStreamInput";
+const _LTFSO = "ListTagsForStreamOutput";
+const _LUS = "LastUploaderStatus";
+const _LUT = "LastUpdatedTime";
+const _M = "Message";
+const _MLMSIMB = "MaxLocalMediaSizeInMB";
+const _MR = "MaxResults";
+const _MRCL = "MappedResourceConfigurationList";
+const _MRCLI = "MappedResourceConfigurationListItem";
+const _MSC = "MediaStorageConfiguration";
+const _MSCe = "MediaSourceConfig";
+const _MT = "MediaType";
+const _MTS = "MessageTtlSeconds";
+const _MUSA = "MediaUriSecretArn";
+const _MUT = "MediaUriType";
+const _NAE = "NotAuthorizedException";
+const _NC = "NotificationConfiguration";
+const _NDC = "NotificationDestinationConfig";
+const _NDRE = "NoDataRetentionException";
+const _NT = "NextToken";
+const _O = "Operation";
+const _P = "Protocol";
+const _Pr = "Protocols";
+const _R = "Role";
+const _RARN = "ResourceARN";
+const _RC = "RecorderConfig";
+const _RE = "ResourceEndpoint";
+const _REL = "ResourceEndpointList";
+const _RELI = "ResourceEndpointListItem";
+const _RIUE = "ResourceInUseException";
+const _RNFE = "ResourceNotFoundException";
+const _RS = "RecorderStatus";
+const _S = "Status";
+const _SARN = "StreamARN";
+const _SC = "ScheduleConfig";
+const _SE = "ScheduleExpression";
+const _SECNFE = "StreamEdgeConfigurationNotFoundException";
+const _SECU = "StartEdgeConfigurationUpdate";
+const _SECUI = "StartEdgeConfigurationUpdateInput";
+const _SECUO = "StartEdgeConfigurationUpdateOutput";
+const _SI = "StreamInfo";
+const _SIL = "StreamInfoList";
+const _SIa = "SamplingInterval";
+const _SMC = "SingleMasterConfiguration";
+const _SMCEC = "SingleMasterChannelEndpointConfiguration";
+const _SN = "StreamName";
+const _SNC = "StreamNameCondition";
+const _SOFS = "StrategyOnFullSize";
+const _SS = "SyncStatus";
+const _T = "Tags";
+const _TKL = "TagKeyList";
+const _TL = "TagList";
+const _TOCL = "TagOnCreateList";
+const _TPRELE = "TagsPerResourceExceededLimitException";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _TS = "TagStream";
+const _TSI = "TagStreamInput";
+const _TSO = "TagStreamOutput";
+const _Ta = "Tag";
+const _Ty = "Type";
+const _U = "Uri";
+const _UC = "UploaderConfig";
+const _UDR = "UpdateDataRetention";
+const _UDRI = "UpdateDataRetentionInput";
+const _UDRO = "UpdateDataRetentionOutput";
+const _UIGC = "UpdateImageGenerationConfiguration";
+const _UIGCI = "UpdateImageGenerationConfigurationInput";
+const _UIGCO = "UpdateImageGenerationConfigurationOutput";
+const _UMSC = "UpdateMediaStorageConfiguration";
+const _UMSCI = "UpdateMediaStorageConfigurationInput";
+const _UMSCO = "UpdateMediaStorageConfigurationOutput";
+const _UNC = "UpdateNotificationConfiguration";
+const _UNCI = "UpdateNotificationConfigurationInput";
+const _UNCO = "UpdateNotificationConfigurationOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _US = "UploaderStatus";
+const _USC = "UpdateSignalingChannel";
+const _USCI = "UpdateSignalingChannelInput";
+const _USCO = "UpdateSignalingChannelOutput";
+const _USI = "UntagStreamInput";
+const _USIp = "UpdateStreamInput";
+const _USO = "UntagStreamOutput";
+const _USOp = "UpdateStreamOutput";
+const _USn = "UntagStream";
+const _USp = "UpdateStream";
+const _V = "Version";
+const _VME = "VersionMismatchException";
+const _Va = "Value";
+const _WP = "WidthPixels";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.kinesisvideo";
+const n0 = "com.amazonaws.kinesisvideo";
+var MediaUriSecretArn = [0, n0, _MUSA, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AccountChannelLimitExceededException = [
+    -3,
+    n0,
+    _ACLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccountChannelLimitExceededException, AccountChannelLimitExceededException$1);
+var AccountStreamLimitExceededException = [
+    -3,
+    n0,
+    _ASLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccountStreamLimitExceededException, AccountStreamLimitExceededException$1);
+var ChannelInfo = [
+    3,
+    n0,
+    _CI,
+    0,
+    [_CN, _CARN, _CT, _CS, _CTr, _SMC, _V],
+    [0, 0, 0, 0, 4, () => SingleMasterConfiguration, 0],
+];
+var ChannelNameCondition = [3, n0, _CNC, 0, [_CO, _CV], [0, 0]];
+var ClientLimitExceededException = [
+    -3,
+    n0,
+    _CLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ClientLimitExceededException, ClientLimitExceededException$1);
+var CreateSignalingChannelInput = [
+    3,
+    n0,
+    _CSCI,
+    0,
+    [_CN, _CT, _SMC, _T],
+    [0, 0, () => SingleMasterConfiguration, () => TagOnCreateList],
+];
+var CreateSignalingChannelOutput = [3, n0, _CSCO, 0, [_CARN], [0]];
+var CreateStreamInput = [
+    3,
+    n0,
+    _CSI,
+    0,
+    [_DN, _SN, _MT, _KKI, _DRIH, _T],
+    [0, 0, 0, 0, 1, 128 | 0],
+];
+var CreateStreamOutput = [3, n0, _CSO, 0, [_SARN], [0]];
+var DeleteEdgeConfigurationInput = [3, n0, _DECI, 0, [_SN, _SARN], [0, 0]];
+var DeleteEdgeConfigurationOutput = [3, n0, _DECO, 0, [], []];
+var DeleteSignalingChannelInput = [3, n0, _DSCI, 0, [_CARN, _CVu], [0, 0]];
+var DeleteSignalingChannelOutput = [3, n0, _DSCO, 0, [], []];
+var DeleteStreamInput = [3, n0, _DSI, 0, [_SARN, _CVu], [0, 0]];
+var DeleteStreamOutput = [3, n0, _DSO, 0, [], []];
+var DeletionConfig = [3, n0, _DC, 0, [_ERIH, _LSC, _DAU], [1, () => LocalSizeConfig, 2]];
+var DescribeEdgeConfigurationInput = [3, n0, _DECIe, 0, [_SN, _SARN], [0, 0]];
+var DescribeEdgeConfigurationOutput = [
+    3,
+    n0,
+    _DECOe,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC, _EAS],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig, 0], () => EdgeAgentStatus],
+];
+var DescribeImageGenerationConfigurationInput = [3, n0, _DIGCI, 0, [_SN, _SARN], [0, 0]];
+var DescribeImageGenerationConfigurationOutput = [
+    3,
+    n0,
+    _DIGCO,
+    0,
+    [_IGC],
+    [() => ImageGenerationConfiguration],
+];
+var DescribeMappedResourceConfigurationInput = [
+    3,
+    n0,
+    _DMRCI,
+    0,
+    [_SN, _SARN, _MR, _NT],
+    [0, 0, 1, 0],
+];
+var DescribeMappedResourceConfigurationOutput = [
+    3,
+    n0,
+    _DMRCO,
+    0,
+    [_MRCL, _NT],
+    [() => MappedResourceConfigurationList, 0],
+];
+var DescribeMediaStorageConfigurationInput = [3, n0, _DMSCI, 0, [_CN, _CARN], [0, 0]];
+var DescribeMediaStorageConfigurationOutput = [
+    3,
+    n0,
+    _DMSCO,
+    0,
+    [_MSC],
+    [() => MediaStorageConfiguration],
+];
+var DescribeNotificationConfigurationInput = [3, n0, _DNCI, 0, [_SN, _SARN], [0, 0]];
+var DescribeNotificationConfigurationOutput = [
+    3,
+    n0,
+    _DNCO,
+    0,
+    [_NC],
+    [() => NotificationConfiguration],
+];
+var DescribeSignalingChannelInput = [3, n0, _DSCIe, 0, [_CN, _CARN], [0, 0]];
+var DescribeSignalingChannelOutput = [3, n0, _DSCOe, 0, [_CI], [() => ChannelInfo]];
+var DescribeStreamInput = [3, n0, _DSIe, 0, [_SN, _SARN], [0, 0]];
+var DescribeStreamOutput = [3, n0, _DSOe, 0, [_SI], [() => StreamInfo]];
+var DeviceStreamLimitExceededException = [
+    -3,
+    n0,
+    _DSLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DeviceStreamLimitExceededException, DeviceStreamLimitExceededException$1);
+var EdgeAgentStatus = [
+    3,
+    n0,
+    _EAS,
+    0,
+    [_LRS, _LUS],
+    [() => LastRecorderStatus, () => LastUploaderStatus],
+];
+var EdgeConfig = [
+    3,
+    n0,
+    _EC,
+    0,
+    [_HDA, _RC, _UC, _DC],
+    [0, [() => RecorderConfig, 0], () => UploaderConfig, () => DeletionConfig],
+];
+var GetDataEndpointInput = [3, n0, _GDEI, 0, [_SN, _SARN, _APIN], [0, 0, 0]];
+var GetDataEndpointOutput = [3, n0, _GDEO, 0, [_DE], [0]];
+var GetSignalingChannelEndpointInput = [
+    3,
+    n0,
+    _GSCEI,
+    0,
+    [_CARN, _SMCEC],
+    [0, () => SingleMasterChannelEndpointConfiguration],
+];
+var GetSignalingChannelEndpointOutput = [
+    3,
+    n0,
+    _GSCEO,
+    0,
+    [_REL],
+    [() => ResourceEndpointList],
+];
+var ImageGenerationConfiguration = [
+    3,
+    n0,
+    _IGC,
+    0,
+    [_S, _IST, _DCe, _SIa, _F, _FC, _WP, _HP],
+    [0, 0, () => ImageGenerationDestinationConfig, 1, 0, 128 | 0, 1, 1],
+];
+var ImageGenerationDestinationConfig = [3, n0, _IGDC, 0, [_U, _DR], [0, 0]];
+var InvalidArgumentException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArgumentException, InvalidArgumentException$1);
+var InvalidDeviceException = [
+    -3,
+    n0,
+    _IDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidDeviceException, InvalidDeviceException$1);
+var InvalidResourceFormatException = [
+    -3,
+    n0,
+    _IRFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidResourceFormatException, InvalidResourceFormatException$1);
+var LastRecorderStatus = [3, n0, _LRS, 0, [_JSD, _LCT, _LUT, _RS], [0, 4, 4, 0]];
+var LastUploaderStatus = [3, n0, _LUS, 0, [_JSD, _LCT, _LUT, _US], [0, 4, 4, 0]];
+var ListEdgeAgentConfigurationsEdgeConfig = [
+    3,
+    n0,
+    _LEACEC,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig, 0]],
+];
+var ListEdgeAgentConfigurationsInput = [3, n0, _LEACI, 0, [_HDA, _MR, _NT], [0, 1, 0]];
+var ListEdgeAgentConfigurationsOutput = [
+    3,
+    n0,
+    _LEACO,
+    0,
+    [_ECd, _NT],
+    [[() => ListEdgeAgentConfigurationsEdgeConfigList, 0], 0],
+];
+var ListSignalingChannelsInput = [
+    3,
+    n0,
+    _LSCI,
+    0,
+    [_MR, _NT, _CNC],
+    [1, 0, () => ChannelNameCondition],
+];
+var ListSignalingChannelsOutput = [
+    3,
+    n0,
+    _LSCO,
+    0,
+    [_CIL, _NT],
+    [() => ChannelInfoList, 0],
+];
+var ListStreamsInput = [
+    3,
+    n0,
+    _LSI,
+    0,
+    [_MR, _NT, _SNC],
+    [1, 0, () => StreamNameCondition],
+];
+var ListStreamsOutput = [3, n0, _LSO, 0, [_SIL, _NT], [() => StreamInfoList, 0]];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_NT, _RARN], [0, 0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_NT, _T], [0, 128 | 0]];
+var ListTagsForStreamInput = [3, n0, _LTFSI, 0, [_NT, _SARN, _SN], [0, 0, 0]];
+var ListTagsForStreamOutput = [3, n0, _LTFSO, 0, [_NT, _T], [0, 128 | 0]];
+var LocalSizeConfig = [3, n0, _LSC, 0, [_MLMSIMB, _SOFS], [1, 0]];
+var MappedResourceConfigurationListItem = [3, n0, _MRCLI, 0, [_Ty, _ARN], [0, 0]];
+var MediaSourceConfig = [
+    3,
+    n0,
+    _MSCe,
+    0,
+    [_MUSA, _MUT],
+    [[() => MediaUriSecretArn, 0], 0],
+];
+var MediaStorageConfiguration = [3, n0, _MSC, 0, [_SARN, _S], [0, 0]];
+var NoDataRetentionException = [
+    -3,
+    n0,
+    _NDRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NoDataRetentionException, NoDataRetentionException$1);
+var NotAuthorizedException = [
+    -3,
+    n0,
+    _NAE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotAuthorizedException, NotAuthorizedException$1);
+var NotificationConfiguration = [
+    3,
+    n0,
+    _NC,
+    0,
+    [_S, _DCe],
+    [0, () => NotificationDestinationConfig],
+];
+var NotificationDestinationConfig = [3, n0, _NDC, 0, [_U], [0]];
+var RecorderConfig = [
+    3,
+    n0,
+    _RC,
+    0,
+    [_MSCe, _SC],
+    [[() => MediaSourceConfig, 0], () => ScheduleConfig],
+];
+var ResourceEndpointListItem = [3, n0, _RELI, 0, [_P, _RE], [0, 0]];
+var ResourceInUseException = [
+    -3,
+    n0,
+    _RIUE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceInUseException, ResourceInUseException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ScheduleConfig = [3, n0, _SC, 0, [_SE, _DIS], [0, 1]];
+var SingleMasterChannelEndpointConfiguration = [3, n0, _SMCEC, 0, [_Pr, _R], [64 | 0, 0]];
+var SingleMasterConfiguration = [3, n0, _SMC, 0, [_MTS], [1]];
+var StartEdgeConfigurationUpdateInput = [
+    3,
+    n0,
+    _SECUI,
+    0,
+    [_SN, _SARN, _EC],
+    [0, 0, [() => EdgeConfig, 0]],
+];
+var StartEdgeConfigurationUpdateOutput = [
+    3,
+    n0,
+    _SECUO,
+    0,
+    [_SN, _SARN, _CTr, _LUT, _SS, _FSD, _EC],
+    [0, 0, 4, 4, 0, 0, [() => EdgeConfig, 0]],
+];
+var StreamEdgeConfigurationNotFoundException = [
+    -3,
+    n0,
+    _SECNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StreamEdgeConfigurationNotFoundException, StreamEdgeConfigurationNotFoundException$1);
+var StreamInfo = [
+    3,
+    n0,
+    _SI,
+    0,
+    [_DN, _SN, _SARN, _MT, _KKI, _V, _S, _CTr, _DRIH],
+    [0, 0, 0, 0, 0, 0, 0, 4, 1],
+];
+var StreamNameCondition = [3, n0, _SNC, 0, [_CO, _CV], [0, 0]];
+var Tag = [3, n0, _Ta, 0, [_K, _Va], [0, 0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_RARN, _T], [0, () => TagList]];
+var TagResourceOutput = [3, n0, _TRO, 0, [], []];
+var TagsPerResourceExceededLimitException = [
+    -3,
+    n0,
+    _TPRELE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TagsPerResourceExceededLimitException, TagsPerResourceExceededLimitException$1);
+var TagStreamInput = [3, n0, _TSI, 0, [_SARN, _SN, _T], [0, 0, 128 | 0]];
+var TagStreamOutput = [3, n0, _TSO, 0, [], []];
+var UntagResourceInput = [3, n0, _URI, 0, [_RARN, _TKL], [0, 64 | 0]];
+var UntagResourceOutput = [3, n0, _URO, 0, [], []];
+var UntagStreamInput = [3, n0, _USI, 0, [_SARN, _SN, _TKL], [0, 0, 64 | 0]];
+var UntagStreamOutput = [3, n0, _USO, 0, [], []];
+var UpdateDataRetentionInput = [
+    3,
+    n0,
+    _UDRI,
+    0,
+    [_SN, _SARN, _CVu, _O, _DRCIH],
+    [0, 0, 0, 0, 1],
+];
+var UpdateDataRetentionOutput = [3, n0, _UDRO, 0, [], []];
+var UpdateImageGenerationConfigurationInput = [
+    3,
+    n0,
+    _UIGCI,
+    0,
+    [_SN, _SARN, _IGC],
+    [0, 0, () => ImageGenerationConfiguration],
+];
+var UpdateImageGenerationConfigurationOutput = [3, n0, _UIGCO, 0, [], []];
+var UpdateMediaStorageConfigurationInput = [
+    3,
+    n0,
+    _UMSCI,
+    0,
+    [_CARN, _MSC],
+    [0, () => MediaStorageConfiguration],
+];
+var UpdateMediaStorageConfigurationOutput = [3, n0, _UMSCO, 0, [], []];
+var UpdateNotificationConfigurationInput = [
+    3,
+    n0,
+    _UNCI,
+    0,
+    [_SN, _SARN, _NC],
+    [0, 0, () => NotificationConfiguration],
+];
+var UpdateNotificationConfigurationOutput = [3, n0, _UNCO, 0, [], []];
+var UpdateSignalingChannelInput = [
+    3,
+    n0,
+    _USCI,
+    0,
+    [_CARN, _CVu, _SMC],
+    [0, 0, () => SingleMasterConfiguration],
+];
+var UpdateSignalingChannelOutput = [3, n0, _USCO, 0, [], []];
+var UpdateStreamInput = [3, n0, _USIp, 0, [_SN, _SARN, _CVu, _DN, _MT], [0, 0, 0, 0, 0]];
+var UpdateStreamOutput = [3, n0, _USOp, 0, [], []];
+var UploaderConfig = [3, n0, _UC, 0, [_SC], [() => ScheduleConfig]];
+var VersionMismatchException = [
+    -3,
+    n0,
+    _VME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(VersionMismatchException, VersionMismatchException$1);
+var KinesisVideoServiceException = [-3, _s, "KinesisVideoServiceException", 0, [], []];
+schema.TypeRegistry.for(_s).registerError(KinesisVideoServiceException, KinesisVideoServiceException$1);
+var ChannelInfoList = [1, n0, _CIL, 0, () => ChannelInfo];
+var ListEdgeAgentConfigurationsEdgeConfigList = [
+    1,
+    n0,
+    _LEACECL,
+    0,
+    [() => ListEdgeAgentConfigurationsEdgeConfig, 0],
+];
+var MappedResourceConfigurationList = [
+    1,
+    n0,
+    _MRCL,
+    0,
+    () => MappedResourceConfigurationListItem,
+];
+var ResourceEndpointList = [1, n0, _REL, 0, () => ResourceEndpointListItem];
+var StreamInfoList = [1, n0, _SIL, 0, () => StreamInfo];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var TagOnCreateList = [1, n0, _TOCL, 0, () => Tag];
+var CreateSignalingChannel = [
+    9,
+    n0,
+    _CSC,
+    {
+        [_h]: ["POST", "/createSignalingChannel", 200],
+    },
+    () => CreateSignalingChannelInput,
+    () => CreateSignalingChannelOutput,
+];
+var CreateStream = [
+    9,
+    n0,
+    _CSr,
+    {
+        [_h]: ["POST", "/createStream", 200],
+    },
+    () => CreateStreamInput,
+    () => CreateStreamOutput,
+];
+var DeleteEdgeConfiguration = [
+    9,
+    n0,
+    _DEC,
+    {
+        [_h]: ["POST", "/deleteEdgeConfiguration", 200],
+    },
+    () => DeleteEdgeConfigurationInput,
+    () => DeleteEdgeConfigurationOutput,
+];
+var DeleteSignalingChannel = [
+    9,
+    n0,
+    _DSC,
+    {
+        [_h]: ["POST", "/deleteSignalingChannel", 200],
+    },
+    () => DeleteSignalingChannelInput,
+    () => DeleteSignalingChannelOutput,
+];
+var DeleteStream = [
+    9,
+    n0,
+    _DS,
+    {
+        [_h]: ["POST", "/deleteStream", 200],
+    },
+    () => DeleteStreamInput,
+    () => DeleteStreamOutput,
+];
+var DescribeEdgeConfiguration = [
+    9,
+    n0,
+    _DECe,
+    {
+        [_h]: ["POST", "/describeEdgeConfiguration", 200],
+    },
+    () => DescribeEdgeConfigurationInput,
+    () => DescribeEdgeConfigurationOutput,
+];
+var DescribeImageGenerationConfiguration = [
+    9,
+    n0,
+    _DIGC,
+    {
+        [_h]: ["POST", "/describeImageGenerationConfiguration", 200],
+    },
+    () => DescribeImageGenerationConfigurationInput,
+    () => DescribeImageGenerationConfigurationOutput,
+];
+var DescribeMappedResourceConfiguration = [
+    9,
+    n0,
+    _DMRC,
+    {
+        [_h]: ["POST", "/describeMappedResourceConfiguration", 200],
+    },
+    () => DescribeMappedResourceConfigurationInput,
+    () => DescribeMappedResourceConfigurationOutput,
+];
+var DescribeMediaStorageConfiguration = [
+    9,
+    n0,
+    _DMSC,
+    {
+        [_h]: ["POST", "/describeMediaStorageConfiguration", 200],
+    },
+    () => DescribeMediaStorageConfigurationInput,
+    () => DescribeMediaStorageConfigurationOutput,
+];
+var DescribeNotificationConfiguration = [
+    9,
+    n0,
+    _DNC,
+    {
+        [_h]: ["POST", "/describeNotificationConfiguration", 200],
+    },
+    () => DescribeNotificationConfigurationInput,
+    () => DescribeNotificationConfigurationOutput,
+];
+var DescribeSignalingChannel = [
+    9,
+    n0,
+    _DSCe,
+    {
+        [_h]: ["POST", "/describeSignalingChannel", 200],
+    },
+    () => DescribeSignalingChannelInput,
+    () => DescribeSignalingChannelOutput,
+];
+var DescribeStream = [
+    9,
+    n0,
+    _DSe,
+    {
+        [_h]: ["POST", "/describeStream", 200],
+    },
+    () => DescribeStreamInput,
+    () => DescribeStreamOutput,
+];
+var GetDataEndpoint = [
+    9,
+    n0,
+    _GDE,
+    {
+        [_h]: ["POST", "/getDataEndpoint", 200],
+    },
+    () => GetDataEndpointInput,
+    () => GetDataEndpointOutput,
+];
+var GetSignalingChannelEndpoint = [
+    9,
+    n0,
+    _GSCE,
+    {
+        [_h]: ["POST", "/getSignalingChannelEndpoint", 200],
+    },
+    () => GetSignalingChannelEndpointInput,
+    () => GetSignalingChannelEndpointOutput,
+];
+var ListEdgeAgentConfigurations = [
+    9,
+    n0,
+    _LEAC,
+    {
+        [_h]: ["POST", "/listEdgeAgentConfigurations", 200],
+    },
+    () => ListEdgeAgentConfigurationsInput,
+    () => ListEdgeAgentConfigurationsOutput,
+];
+var ListSignalingChannels = [
+    9,
+    n0,
+    _LSCi,
+    {
+        [_h]: ["POST", "/listSignalingChannels", 200],
+    },
+    () => ListSignalingChannelsInput,
+    () => ListSignalingChannelsOutput,
+];
+var ListStreams = [
+    9,
+    n0,
+    _LS,
+    {
+        [_h]: ["POST", "/listStreams", 200],
+    },
+    () => ListStreamsInput,
+    () => ListStreamsOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["POST", "/ListTagsForResource", 200],
+    },
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var ListTagsForStream = [
+    9,
+    n0,
+    _LTFS,
+    {
+        [_h]: ["POST", "/listTagsForStream", 200],
+    },
+    () => ListTagsForStreamInput,
+    () => ListTagsForStreamOutput,
+];
+var StartEdgeConfigurationUpdate = [
+    9,
+    n0,
+    _SECU,
+    {
+        [_h]: ["POST", "/startEdgeConfigurationUpdate", 200],
+    },
+    () => StartEdgeConfigurationUpdateInput,
+    () => StartEdgeConfigurationUpdateOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/TagResource", 200],
+    },
+    () => TagResourceInput,
+    () => TagResourceOutput,
+];
+var TagStream = [
+    9,
+    n0,
+    _TS,
+    {
+        [_h]: ["POST", "/tagStream", 200],
+    },
+    () => TagStreamInput,
+    () => TagStreamOutput,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/UntagResource", 200],
+    },
+    () => UntagResourceInput,
+    () => UntagResourceOutput,
+];
+var UntagStream = [
+    9,
+    n0,
+    _USn,
+    {
+        [_h]: ["POST", "/untagStream", 200],
+    },
+    () => UntagStreamInput,
+    () => UntagStreamOutput,
+];
+var UpdateDataRetention = [
+    9,
+    n0,
+    _UDR,
+    {
+        [_h]: ["POST", "/updateDataRetention", 200],
+    },
+    () => UpdateDataRetentionInput,
+    () => UpdateDataRetentionOutput,
+];
+var UpdateImageGenerationConfiguration = [
+    9,
+    n0,
+    _UIGC,
+    {
+        [_h]: ["POST", "/updateImageGenerationConfiguration", 200],
+    },
+    () => UpdateImageGenerationConfigurationInput,
+    () => UpdateImageGenerationConfigurationOutput,
+];
+var UpdateMediaStorageConfiguration = [
+    9,
+    n0,
+    _UMSC,
+    {
+        [_h]: ["POST", "/updateMediaStorageConfiguration", 200],
+    },
+    () => UpdateMediaStorageConfigurationInput,
+    () => UpdateMediaStorageConfigurationOutput,
+];
+var UpdateNotificationConfiguration = [
+    9,
+    n0,
+    _UNC,
+    {
+        [_h]: ["POST", "/updateNotificationConfiguration", 200],
+    },
+    () => UpdateNotificationConfigurationInput,
+    () => UpdateNotificationConfigurationOutput,
+];
+var UpdateSignalingChannel = [
+    9,
+    n0,
+    _USC,
+    {
+        [_h]: ["POST", "/updateSignalingChannel", 200],
+    },
+    () => UpdateSignalingChannelInput,
+    () => UpdateSignalingChannelOutput,
+];
+var UpdateStream = [
+    9,
+    n0,
+    _USp,
+    {
+        [_h]: ["POST", "/updateStream", 200],
+    },
+    () => UpdateStreamInput,
+    () => UpdateStreamOutput,
+];
 
 class CreateSignalingChannelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "CreateSignalingChannel", {})
     .n("KinesisVideoClient", "CreateSignalingChannelCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateSignalingChannelCommand)
-    .de(de_CreateSignalingChannelCommand)
+    .sc(CreateSignalingChannel)
     .build() {
 }
 
@@ -1642,16 +1428,11 @@ class CreateStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "CreateStream", {})
     .n("KinesisVideoClient", "CreateStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateStreamCommand)
-    .de(de_CreateStreamCommand)
+    .sc(CreateStream)
     .build() {
 }
 
@@ -1659,16 +1440,11 @@ class DeleteEdgeConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DeleteEdgeConfiguration", {})
     .n("KinesisVideoClient", "DeleteEdgeConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteEdgeConfigurationCommand)
-    .de(de_DeleteEdgeConfigurationCommand)
+    .sc(DeleteEdgeConfiguration)
     .build() {
 }
 
@@ -1676,16 +1452,11 @@ class DeleteSignalingChannelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DeleteSignalingChannel", {})
     .n("KinesisVideoClient", "DeleteSignalingChannelCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSignalingChannelCommand)
-    .de(de_DeleteSignalingChannelCommand)
+    .sc(DeleteSignalingChannel)
     .build() {
 }
 
@@ -1693,16 +1464,11 @@ class DeleteStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DeleteStream", {})
     .n("KinesisVideoClient", "DeleteStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStreamCommand)
-    .de(de_DeleteStreamCommand)
+    .sc(DeleteStream)
     .build() {
 }
 
@@ -1710,16 +1476,11 @@ class DescribeEdgeConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeEdgeConfiguration", {})
     .n("KinesisVideoClient", "DescribeEdgeConfigurationCommand")
-    .f(void 0, DescribeEdgeConfigurationOutputFilterSensitiveLog)
-    .ser(se_DescribeEdgeConfigurationCommand)
-    .de(de_DescribeEdgeConfigurationCommand)
+    .sc(DescribeEdgeConfiguration)
     .build() {
 }
 
@@ -1727,16 +1488,11 @@ class DescribeImageGenerationConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeImageGenerationConfiguration", {})
     .n("KinesisVideoClient", "DescribeImageGenerationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeImageGenerationConfigurationCommand)
-    .de(de_DescribeImageGenerationConfigurationCommand)
+    .sc(DescribeImageGenerationConfiguration)
     .build() {
 }
 
@@ -1744,16 +1500,11 @@ class DescribeMappedResourceConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeMappedResourceConfiguration", {})
     .n("KinesisVideoClient", "DescribeMappedResourceConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeMappedResourceConfigurationCommand)
-    .de(de_DescribeMappedResourceConfigurationCommand)
+    .sc(DescribeMappedResourceConfiguration)
     .build() {
 }
 
@@ -1761,16 +1512,11 @@ class DescribeMediaStorageConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeMediaStorageConfiguration", {})
     .n("KinesisVideoClient", "DescribeMediaStorageConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeMediaStorageConfigurationCommand)
-    .de(de_DescribeMediaStorageConfigurationCommand)
+    .sc(DescribeMediaStorageConfiguration)
     .build() {
 }
 
@@ -1778,16 +1524,11 @@ class DescribeNotificationConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeNotificationConfiguration", {})
     .n("KinesisVideoClient", "DescribeNotificationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeNotificationConfigurationCommand)
-    .de(de_DescribeNotificationConfigurationCommand)
+    .sc(DescribeNotificationConfiguration)
     .build() {
 }
 
@@ -1795,16 +1536,11 @@ class DescribeSignalingChannelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeSignalingChannel", {})
     .n("KinesisVideoClient", "DescribeSignalingChannelCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeSignalingChannelCommand)
-    .de(de_DescribeSignalingChannelCommand)
+    .sc(DescribeSignalingChannel)
     .build() {
 }
 
@@ -1812,16 +1548,11 @@ class DescribeStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "DescribeStream", {})
     .n("KinesisVideoClient", "DescribeStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeStreamCommand)
-    .de(de_DescribeStreamCommand)
+    .sc(DescribeStream)
     .build() {
 }
 
@@ -1829,16 +1560,11 @@ class GetDataEndpointCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "GetDataEndpoint", {})
     .n("KinesisVideoClient", "GetDataEndpointCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataEndpointCommand)
-    .de(de_GetDataEndpointCommand)
+    .sc(GetDataEndpoint)
     .build() {
 }
 
@@ -1846,16 +1572,11 @@ class GetSignalingChannelEndpointCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "GetSignalingChannelEndpoint", {})
     .n("KinesisVideoClient", "GetSignalingChannelEndpointCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSignalingChannelEndpointCommand)
-    .de(de_GetSignalingChannelEndpointCommand)
+    .sc(GetSignalingChannelEndpoint)
     .build() {
 }
 
@@ -1863,16 +1584,11 @@ class ListEdgeAgentConfigurationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "ListEdgeAgentConfigurations", {})
     .n("KinesisVideoClient", "ListEdgeAgentConfigurationsCommand")
-    .f(void 0, ListEdgeAgentConfigurationsOutputFilterSensitiveLog)
-    .ser(se_ListEdgeAgentConfigurationsCommand)
-    .de(de_ListEdgeAgentConfigurationsCommand)
+    .sc(ListEdgeAgentConfigurations)
     .build() {
 }
 
@@ -1880,16 +1596,11 @@ class ListSignalingChannelsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "ListSignalingChannels", {})
     .n("KinesisVideoClient", "ListSignalingChannelsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSignalingChannelsCommand)
-    .de(de_ListSignalingChannelsCommand)
+    .sc(ListSignalingChannels)
     .build() {
 }
 
@@ -1897,16 +1608,11 @@ class ListStreamsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "ListStreams", {})
     .n("KinesisVideoClient", "ListStreamsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamsCommand)
-    .de(de_ListStreamsCommand)
+    .sc(ListStreams)
     .build() {
 }
 
@@ -1914,16 +1620,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "ListTagsForResource", {})
     .n("KinesisVideoClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1931,16 +1632,11 @@ class ListTagsForStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "ListTagsForStream", {})
     .n("KinesisVideoClient", "ListTagsForStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForStreamCommand)
-    .de(de_ListTagsForStreamCommand)
+    .sc(ListTagsForStream)
     .build() {
 }
 
@@ -1948,16 +1644,11 @@ class StartEdgeConfigurationUpdateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "StartEdgeConfigurationUpdate", {})
     .n("KinesisVideoClient", "StartEdgeConfigurationUpdateCommand")
-    .f(StartEdgeConfigurationUpdateInputFilterSensitiveLog, StartEdgeConfigurationUpdateOutputFilterSensitiveLog)
-    .ser(se_StartEdgeConfigurationUpdateCommand)
-    .de(de_StartEdgeConfigurationUpdateCommand)
+    .sc(StartEdgeConfigurationUpdate)
     .build() {
 }
 
@@ -1965,16 +1656,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "TagResource", {})
     .n("KinesisVideoClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1982,16 +1668,11 @@ class TagStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "TagStream", {})
     .n("KinesisVideoClient", "TagStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_TagStreamCommand)
-    .de(de_TagStreamCommand)
+    .sc(TagStream)
     .build() {
 }
 
@@ -1999,16 +1680,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UntagResource", {})
     .n("KinesisVideoClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2016,16 +1692,11 @@ class UntagStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UntagStream", {})
     .n("KinesisVideoClient", "UntagStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagStreamCommand)
-    .de(de_UntagStreamCommand)
+    .sc(UntagStream)
     .build() {
 }
 
@@ -2033,16 +1704,11 @@ class UpdateDataRetentionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateDataRetention", {})
     .n("KinesisVideoClient", "UpdateDataRetentionCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataRetentionCommand)
-    .de(de_UpdateDataRetentionCommand)
+    .sc(UpdateDataRetention)
     .build() {
 }
 
@@ -2050,16 +1716,11 @@ class UpdateImageGenerationConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateImageGenerationConfiguration", {})
     .n("KinesisVideoClient", "UpdateImageGenerationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateImageGenerationConfigurationCommand)
-    .de(de_UpdateImageGenerationConfigurationCommand)
+    .sc(UpdateImageGenerationConfiguration)
     .build() {
 }
 
@@ -2067,16 +1728,11 @@ class UpdateMediaStorageConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateMediaStorageConfiguration", {})
     .n("KinesisVideoClient", "UpdateMediaStorageConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateMediaStorageConfigurationCommand)
-    .de(de_UpdateMediaStorageConfigurationCommand)
+    .sc(UpdateMediaStorageConfiguration)
     .build() {
 }
 
@@ -2084,16 +1740,11 @@ class UpdateNotificationConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateNotificationConfiguration", {})
     .n("KinesisVideoClient", "UpdateNotificationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateNotificationConfigurationCommand)
-    .de(de_UpdateNotificationConfigurationCommand)
+    .sc(UpdateNotificationConfiguration)
     .build() {
 }
 
@@ -2101,16 +1752,11 @@ class UpdateSignalingChannelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateSignalingChannel", {})
     .n("KinesisVideoClient", "UpdateSignalingChannelCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateSignalingChannelCommand)
-    .de(de_UpdateSignalingChannelCommand)
+    .sc(UpdateSignalingChannel)
     .build() {
 }
 
@@ -2118,16 +1764,11 @@ class UpdateStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KinesisVideo_20170930", "UpdateStream", {})
     .n("KinesisVideoClient", "UpdateStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateStreamCommand)
-    .de(de_UpdateStreamCommand)
+    .sc(UpdateStream)
     .build() {
 }
 
@@ -2184,13 +1825,13 @@ Object.defineProperty(exports, "__Client", {
     get: function () { return smithyClient.Client; }
 });
 exports.APIName = APIName;
-exports.AccessDeniedException = AccessDeniedException;
-exports.AccountChannelLimitExceededException = AccountChannelLimitExceededException;
-exports.AccountStreamLimitExceededException = AccountStreamLimitExceededException;
+exports.AccessDeniedException = AccessDeniedException$1;
+exports.AccountChannelLimitExceededException = AccountChannelLimitExceededException$1;
+exports.AccountStreamLimitExceededException = AccountStreamLimitExceededException$1;
 exports.ChannelProtocol = ChannelProtocol;
 exports.ChannelRole = ChannelRole;
 exports.ChannelType = ChannelType;
-exports.ClientLimitExceededException = ClientLimitExceededException;
+exports.ClientLimitExceededException = ClientLimitExceededException$1;
 exports.ComparisonOperator = ComparisonOperator;
 exports.ConfigurationStatus = ConfigurationStatus;
 exports.CreateSignalingChannelCommand = CreateSignalingChannelCommand;
@@ -2199,52 +1840,44 @@ exports.DeleteEdgeConfigurationCommand = DeleteEdgeConfigurationCommand;
 exports.DeleteSignalingChannelCommand = DeleteSignalingChannelCommand;
 exports.DeleteStreamCommand = DeleteStreamCommand;
 exports.DescribeEdgeConfigurationCommand = DescribeEdgeConfigurationCommand;
-exports.DescribeEdgeConfigurationOutputFilterSensitiveLog = DescribeEdgeConfigurationOutputFilterSensitiveLog;
 exports.DescribeImageGenerationConfigurationCommand = DescribeImageGenerationConfigurationCommand;
 exports.DescribeMappedResourceConfigurationCommand = DescribeMappedResourceConfigurationCommand;
 exports.DescribeMediaStorageConfigurationCommand = DescribeMediaStorageConfigurationCommand;
 exports.DescribeNotificationConfigurationCommand = DescribeNotificationConfigurationCommand;
 exports.DescribeSignalingChannelCommand = DescribeSignalingChannelCommand;
 exports.DescribeStreamCommand = DescribeStreamCommand;
-exports.DeviceStreamLimitExceededException = DeviceStreamLimitExceededException;
-exports.EdgeConfigFilterSensitiveLog = EdgeConfigFilterSensitiveLog;
+exports.DeviceStreamLimitExceededException = DeviceStreamLimitExceededException$1;
 exports.Format = Format;
 exports.FormatConfigKey = FormatConfigKey;
 exports.GetDataEndpointCommand = GetDataEndpointCommand;
 exports.GetSignalingChannelEndpointCommand = GetSignalingChannelEndpointCommand;
 exports.ImageSelectorType = ImageSelectorType;
-exports.InvalidArgumentException = InvalidArgumentException;
-exports.InvalidDeviceException = InvalidDeviceException;
-exports.InvalidResourceFormatException = InvalidResourceFormatException;
+exports.InvalidArgumentException = InvalidArgumentException$1;
+exports.InvalidDeviceException = InvalidDeviceException$1;
+exports.InvalidResourceFormatException = InvalidResourceFormatException$1;
 exports.KinesisVideo = KinesisVideo;
 exports.KinesisVideoClient = KinesisVideoClient;
-exports.KinesisVideoServiceException = KinesisVideoServiceException;
+exports.KinesisVideoServiceException = KinesisVideoServiceException$1;
 exports.ListEdgeAgentConfigurationsCommand = ListEdgeAgentConfigurationsCommand;
-exports.ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog = ListEdgeAgentConfigurationsEdgeConfigFilterSensitiveLog;
-exports.ListEdgeAgentConfigurationsOutputFilterSensitiveLog = ListEdgeAgentConfigurationsOutputFilterSensitiveLog;
 exports.ListSignalingChannelsCommand = ListSignalingChannelsCommand;
 exports.ListStreamsCommand = ListStreamsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListTagsForStreamCommand = ListTagsForStreamCommand;
-exports.MediaSourceConfigFilterSensitiveLog = MediaSourceConfigFilterSensitiveLog;
 exports.MediaStorageConfigurationStatus = MediaStorageConfigurationStatus;
 exports.MediaUriType = MediaUriType;
-exports.NoDataRetentionException = NoDataRetentionException;
-exports.NotAuthorizedException = NotAuthorizedException;
-exports.RecorderConfigFilterSensitiveLog = RecorderConfigFilterSensitiveLog;
+exports.NoDataRetentionException = NoDataRetentionException$1;
+exports.NotAuthorizedException = NotAuthorizedException$1;
 exports.RecorderStatus = RecorderStatus;
-exports.ResourceInUseException = ResourceInUseException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceInUseException = ResourceInUseException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.StartEdgeConfigurationUpdateCommand = StartEdgeConfigurationUpdateCommand;
-exports.StartEdgeConfigurationUpdateInputFilterSensitiveLog = StartEdgeConfigurationUpdateInputFilterSensitiveLog;
-exports.StartEdgeConfigurationUpdateOutputFilterSensitiveLog = StartEdgeConfigurationUpdateOutputFilterSensitiveLog;
 exports.Status = Status;
 exports.StrategyOnFullSize = StrategyOnFullSize;
-exports.StreamEdgeConfigurationNotFoundException = StreamEdgeConfigurationNotFoundException;
+exports.StreamEdgeConfigurationNotFoundException = StreamEdgeConfigurationNotFoundException$1;
 exports.SyncStatus = SyncStatus;
 exports.TagResourceCommand = TagResourceCommand;
 exports.TagStreamCommand = TagStreamCommand;
-exports.TagsPerResourceExceededLimitException = TagsPerResourceExceededLimitException;
+exports.TagsPerResourceExceededLimitException = TagsPerResourceExceededLimitException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UntagStreamCommand = UntagStreamCommand;
 exports.UpdateDataRetentionCommand = UpdateDataRetentionCommand;
@@ -2255,7 +1888,7 @@ exports.UpdateNotificationConfigurationCommand = UpdateNotificationConfiguration
 exports.UpdateSignalingChannelCommand = UpdateSignalingChannelCommand;
 exports.UpdateStreamCommand = UpdateStreamCommand;
 exports.UploaderStatus = UploaderStatus;
-exports.VersionMismatchException = VersionMismatchException;
+exports.VersionMismatchException = VersionMismatchException$1;
 exports.paginateDescribeMappedResourceConfiguration = paginateDescribeMappedResourceConfiguration;
 exports.paginateListEdgeAgentConfigurations = paginateListEdgeAgentConfigurations;
 exports.paginateListSignalingChannels = paginateListSignalingChannels;