@aws-sdk/client-kinesis 3.927.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 eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
@@ -15,8 +16,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');
 var utilWaiter = require('@smithy/util-waiter');
 
 const resolveClientEndpointParameters = (options) => {
@@ -94,6 +93,7 @@ class KinesisClient extends smithyClient.Client {
         const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
         const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
         this.config = _config_9;
+        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));
@@ -113,14 +113,14 @@ class KinesisClient extends smithyClient.Client {
     }
 }
 
-class KinesisServiceException extends smithyClient.ServiceException {
+let KinesisServiceException$1 = class KinesisServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, KinesisServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends KinesisServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends KinesisServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -131,8 +131,8 @@ class AccessDeniedException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
-class InvalidArgumentException extends KinesisServiceException {
+};
+let InvalidArgumentException$1 = class InvalidArgumentException extends KinesisServiceException$1 {
     name = "InvalidArgumentException";
     $fault = "client";
     constructor(opts) {
@@ -143,8 +143,8 @@ class InvalidArgumentException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, InvalidArgumentException.prototype);
     }
-}
-class LimitExceededException extends KinesisServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends KinesisServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -155,8 +155,8 @@ class LimitExceededException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-class ResourceInUseException extends KinesisServiceException {
+};
+let ResourceInUseException$1 = class ResourceInUseException extends KinesisServiceException$1 {
     name = "ResourceInUseException";
     $fault = "client";
     constructor(opts) {
@@ -167,8 +167,8 @@ class ResourceInUseException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
     }
-}
-class ResourceNotFoundException extends KinesisServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends KinesisServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -179,7 +179,7 @@ class ResourceNotFoundException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
+};
 const ConsumerStatus = {
     ACTIVE: "ACTIVE",
     CREATING: "CREATING",
@@ -189,7 +189,7 @@ const StreamMode = {
     ON_DEMAND: "ON_DEMAND",
     PROVISIONED: "PROVISIONED",
 };
-class ValidationException extends KinesisServiceException {
+let ValidationException$1 = class ValidationException extends KinesisServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -200,7 +200,7 @@ class ValidationException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const MinimumThroughputBillingCommitmentOutputStatus = {
     DISABLED: "DISABLED",
     ENABLED: "ENABLED",
@@ -226,7 +226,7 @@ const StreamStatus = {
     DELETING: "DELETING",
     UPDATING: "UPDATING",
 };
-class ExpiredIteratorException extends KinesisServiceException {
+let ExpiredIteratorException$1 = class ExpiredIteratorException extends KinesisServiceException$1 {
     name = "ExpiredIteratorException";
     $fault = "client";
     constructor(opts) {
@@ -237,8 +237,8 @@ class ExpiredIteratorException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ExpiredIteratorException.prototype);
     }
-}
-class ExpiredNextTokenException extends KinesisServiceException {
+};
+let ExpiredNextTokenException$1 = class ExpiredNextTokenException extends KinesisServiceException$1 {
     name = "ExpiredNextTokenException";
     $fault = "client";
     constructor(opts) {
@@ -249,8 +249,8 @@ class ExpiredNextTokenException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ExpiredNextTokenException.prototype);
     }
-}
-class InternalFailureException extends KinesisServiceException {
+};
+let InternalFailureException$1 = class InternalFailureException extends KinesisServiceException$1 {
     name = "InternalFailureException";
     $fault = "server";
     constructor(opts) {
@@ -261,8 +261,8 @@ class InternalFailureException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, InternalFailureException.prototype);
     }
-}
-class KMSAccessDeniedException extends KinesisServiceException {
+};
+let KMSAccessDeniedException$1 = class KMSAccessDeniedException extends KinesisServiceException$1 {
     name = "KMSAccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -273,8 +273,8 @@ class KMSAccessDeniedException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSAccessDeniedException.prototype);
     }
-}
-class KMSDisabledException extends KinesisServiceException {
+};
+let KMSDisabledException$1 = class KMSDisabledException extends KinesisServiceException$1 {
     name = "KMSDisabledException";
     $fault = "client";
     constructor(opts) {
@@ -285,8 +285,8 @@ class KMSDisabledException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSDisabledException.prototype);
     }
-}
-class KMSInvalidStateException extends KinesisServiceException {
+};
+let KMSInvalidStateException$1 = class KMSInvalidStateException extends KinesisServiceException$1 {
     name = "KMSInvalidStateException";
     $fault = "client";
     constructor(opts) {
@@ -297,8 +297,8 @@ class KMSInvalidStateException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSInvalidStateException.prototype);
     }
-}
-class KMSNotFoundException extends KinesisServiceException {
+};
+let KMSNotFoundException$1 = class KMSNotFoundException extends KinesisServiceException$1 {
     name = "KMSNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -309,8 +309,8 @@ class KMSNotFoundException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSNotFoundException.prototype);
     }
-}
-class KMSOptInRequired extends KinesisServiceException {
+};
+let KMSOptInRequired$1 = class KMSOptInRequired extends KinesisServiceException$1 {
     name = "KMSOptInRequired";
     $fault = "client";
     constructor(opts) {
@@ -321,8 +321,8 @@ class KMSOptInRequired extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSOptInRequired.prototype);
     }
-}
-class KMSThrottlingException extends KinesisServiceException {
+};
+let KMSThrottlingException$1 = class KMSThrottlingException extends KinesisServiceException$1 {
     name = "KMSThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -333,8 +333,8 @@ class KMSThrottlingException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, KMSThrottlingException.prototype);
     }
-}
-class ProvisionedThroughputExceededException extends KinesisServiceException {
+};
+let ProvisionedThroughputExceededException$1 = class ProvisionedThroughputExceededException extends KinesisServiceException$1 {
     name = "ProvisionedThroughputExceededException";
     $fault = "client";
     constructor(opts) {
@@ -345,7 +345,7 @@ class ProvisionedThroughputExceededException extends KinesisServiceException {
         });
         Object.setPrototypeOf(this, ProvisionedThroughputExceededException.prototype);
     }
-}
+};
 const ShardIteratorType = {
     AFTER_SEQUENCE_NUMBER: "AFTER_SEQUENCE_NUMBER",
     AT_SEQUENCE_NUMBER: "AT_SEQUENCE_NUMBER",
@@ -394,1323 +394,932 @@ const MinimumThroughputBillingCommitmentInputStatus = {
 const ScalingType = {
     UNIFORM_SCALING: "UNIFORM_SCALING",
 };
-const SubscribeToShardEventStreamFilterSensitiveLog = (obj) => {
-    if (obj.SubscribeToShardEvent !== undefined)
-        return { SubscribeToShardEvent: obj.SubscribeToShardEvent };
-    if (obj.ResourceNotFoundException !== undefined)
-        return { ResourceNotFoundException: obj.ResourceNotFoundException };
-    if (obj.ResourceInUseException !== undefined)
-        return { ResourceInUseException: obj.ResourceInUseException };
-    if (obj.KMSDisabledException !== undefined)
-        return { KMSDisabledException: obj.KMSDisabledException };
-    if (obj.KMSInvalidStateException !== undefined)
-        return { KMSInvalidStateException: obj.KMSInvalidStateException };
-    if (obj.KMSAccessDeniedException !== undefined)
-        return { KMSAccessDeniedException: obj.KMSAccessDeniedException };
-    if (obj.KMSNotFoundException !== undefined)
-        return { KMSNotFoundException: obj.KMSNotFoundException };
-    if (obj.KMSOptInRequired !== undefined)
-        return { KMSOptInRequired: obj.KMSOptInRequired };
-    if (obj.KMSThrottlingException !== undefined)
-        return { KMSThrottlingException: obj.KMSThrottlingException };
-    if (obj.InternalFailureException !== undefined)
-        return { InternalFailureException: obj.InternalFailureException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const SubscribeToShardOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EventStream && { EventStream: "STREAMING_CONTENT" }),
-});
 
-const se_AddTagsToStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("AddTagsToStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DecreaseStreamRetentionPeriodCommand = async (input, context) => {
-    const headers = sharedHeaders("DecreaseStreamRetentionPeriod");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteResourcePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteResourcePolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeregisterStreamConsumerCommand = async (input, context) => {
-    const headers = sharedHeaders("DeregisterStreamConsumer");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeAccountSettingsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeAccountSettings");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeLimitsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeLimits");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStreamConsumerCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStreamConsumer");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStreamSummaryCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStreamSummary");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DisableEnhancedMonitoringCommand = async (input, context) => {
-    const headers = sharedHeaders("DisableEnhancedMonitoring");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_EnableEnhancedMonitoringCommand = async (input, context) => {
-    const headers = sharedHeaders("EnableEnhancedMonitoring");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetRecordsCommand = async (input, context) => {
-    const headers = sharedHeaders("GetRecords");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetResourcePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("GetResourcePolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetShardIteratorCommand = async (input, context) => {
-    const headers = sharedHeaders("GetShardIterator");
-    let body;
-    body = JSON.stringify(se_GetShardIteratorInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_IncreaseStreamRetentionPeriodCommand = async (input, context) => {
-    const headers = sharedHeaders("IncreaseStreamRetentionPeriod");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListShardsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListShards");
-    let body;
-    body = JSON.stringify(se_ListShardsInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStreamConsumersCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStreamConsumers");
-    let body;
-    body = JSON.stringify(se_ListStreamConsumersInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStreamsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStreams");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_MergeShardsCommand = async (input, context) => {
-    const headers = sharedHeaders("MergeShards");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutRecordCommand = async (input, context) => {
-    const headers = sharedHeaders("PutRecord");
-    let body;
-    body = JSON.stringify(se_PutRecordInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutRecordsCommand = async (input, context) => {
-    const headers = sharedHeaders("PutRecords");
-    let body;
-    body = JSON.stringify(se_PutRecordsInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutResourcePolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("PutResourcePolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterStreamConsumerCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterStreamConsumer");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RemoveTagsFromStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("RemoveTagsFromStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SplitShardCommand = async (input, context) => {
-    const headers = sharedHeaders("SplitShard");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartStreamEncryptionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartStreamEncryption");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StopStreamEncryptionCommand = async (input, context) => {
-    const headers = sharedHeaders("StopStreamEncryption");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SubscribeToShardCommand = async (input, context) => {
-    const headers = sharedHeaders("SubscribeToShard");
-    let body;
-    body = JSON.stringify(se_SubscribeToShardInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateAccountSettingsCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateAccountSettings");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateMaxRecordSizeCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateMaxRecordSize");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateShardCountCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateShardCount");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateStreamModeCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateStreamMode");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateStreamWarmThroughputCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateStreamWarmThroughput");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_AddTagsToStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_CreateStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DecreaseStreamRetentionPeriodCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeleteResourcePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeleteStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeregisterStreamConsumerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DescribeAccountSettingsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeAccountSettingsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLimitsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStreamOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStreamConsumerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStreamConsumerOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStreamSummaryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStreamSummaryOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableEnhancedMonitoringCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableEnhancedMonitoringCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetRecordsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetRecordsOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetResourcePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetShardIteratorCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_IncreaseStreamRetentionPeriodCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_ListShardsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStreamConsumersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListStreamConsumersOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStreamsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListStreamsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_MergeShardsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_PutRecordCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutRecordsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutResourcePolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RegisterStreamConsumerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_RegisterStreamConsumerOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RemoveTagsFromStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_SplitShardCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_StartStreamEncryptionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_StopStreamEncryptionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_SubscribeToShardCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = { EventStream: de_SubscribeToShardEventStream(output.body, context) };
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UpdateAccountSettingsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateAccountSettingsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateMaxRecordSizeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UpdateShardCountCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateStreamModeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UpdateStreamWarmThroughputCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-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.kinesis#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InvalidArgumentException":
-        case "com.amazonaws.kinesis#InvalidArgumentException":
-            throw await de_InvalidArgumentExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.kinesis#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ResourceInUseException":
-        case "com.amazonaws.kinesis#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.kinesis#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.kinesis#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ExpiredIteratorException":
-        case "com.amazonaws.kinesis#ExpiredIteratorException":
-            throw await de_ExpiredIteratorExceptionRes(parsedOutput);
-        case "InternalFailureException":
-        case "com.amazonaws.kinesis#InternalFailureException":
-            throw await de_InternalFailureExceptionRes(parsedOutput);
-        case "KMSAccessDeniedException":
-        case "com.amazonaws.kinesis#KMSAccessDeniedException":
-            throw await de_KMSAccessDeniedExceptionRes(parsedOutput);
-        case "KMSDisabledException":
-        case "com.amazonaws.kinesis#KMSDisabledException":
-            throw await de_KMSDisabledExceptionRes(parsedOutput);
-        case "KMSInvalidStateException":
-        case "com.amazonaws.kinesis#KMSInvalidStateException":
-            throw await de_KMSInvalidStateExceptionRes(parsedOutput);
-        case "KMSNotFoundException":
-        case "com.amazonaws.kinesis#KMSNotFoundException":
-            throw await de_KMSNotFoundExceptionRes(parsedOutput);
-        case "KMSOptInRequired":
-        case "com.amazonaws.kinesis#KMSOptInRequired":
-            throw await de_KMSOptInRequiredRes(parsedOutput);
-        case "KMSThrottlingException":
-        case "com.amazonaws.kinesis#KMSThrottlingException":
-            throw await de_KMSThrottlingExceptionRes(parsedOutput);
-        case "ProvisionedThroughputExceededException":
-        case "com.amazonaws.kinesis#ProvisionedThroughputExceededException":
-            throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput);
-        case "ExpiredNextTokenException":
-        case "com.amazonaws.kinesis#ExpiredNextTokenException":
-            throw await de_ExpiredNextTokenExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExpiredIteratorExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExpiredIteratorException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExpiredNextTokenExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExpiredNextTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalFailureException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidArgumentException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSAccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSAccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSDisabledExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSDisabledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSInvalidStateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSInvalidStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSOptInRequiredRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSOptInRequired({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KMSThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KMSThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ProvisionedThroughputExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ProvisionedThroughputExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceInUseException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_SubscribeToShardEventStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["SubscribeToShardEvent"] != null) {
-            return {
-                SubscribeToShardEvent: await de_SubscribeToShardEvent_event(event["SubscribeToShardEvent"], context),
-            };
-        }
-        if (event["ResourceNotFoundException"] != null) {
-            return {
-                ResourceNotFoundException: await de_ResourceNotFoundException_event(event["ResourceNotFoundException"], context),
-            };
-        }
-        if (event["ResourceInUseException"] != null) {
-            return {
-                ResourceInUseException: await de_ResourceInUseException_event(event["ResourceInUseException"], context),
-            };
-        }
-        if (event["KMSDisabledException"] != null) {
-            return {
-                KMSDisabledException: await de_KMSDisabledException_event(event["KMSDisabledException"], context),
-            };
-        }
-        if (event["KMSInvalidStateException"] != null) {
-            return {
-                KMSInvalidStateException: await de_KMSInvalidStateException_event(event["KMSInvalidStateException"], context),
-            };
-        }
-        if (event["KMSAccessDeniedException"] != null) {
-            return {
-                KMSAccessDeniedException: await de_KMSAccessDeniedException_event(event["KMSAccessDeniedException"], context),
-            };
-        }
-        if (event["KMSNotFoundException"] != null) {
-            return {
-                KMSNotFoundException: await de_KMSNotFoundException_event(event["KMSNotFoundException"], context),
-            };
-        }
-        if (event["KMSOptInRequired"] != null) {
-            return {
-                KMSOptInRequired: await de_KMSOptInRequired_event(event["KMSOptInRequired"], context),
-            };
-        }
-        if (event["KMSThrottlingException"] != null) {
-            return {
-                KMSThrottlingException: await de_KMSThrottlingException_event(event["KMSThrottlingException"], context),
-            };
-        }
-        if (event["InternalFailureException"] != null) {
-            return {
-                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_InternalFailureException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_InternalFailureExceptionRes(parsedOutput);
-};
-const de_KMSAccessDeniedException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSAccessDeniedExceptionRes(parsedOutput);
-};
-const de_KMSDisabledException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSDisabledExceptionRes(parsedOutput);
-};
-const de_KMSInvalidStateException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSInvalidStateExceptionRes(parsedOutput);
-};
-const de_KMSNotFoundException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSNotFoundExceptionRes(parsedOutput);
-};
-const de_KMSOptInRequired_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSOptInRequiredRes(parsedOutput);
-};
-const de_KMSThrottlingException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_KMSThrottlingExceptionRes(parsedOutput);
-};
-const de_ResourceInUseException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ResourceInUseExceptionRes(parsedOutput);
-};
-const de_ResourceNotFoundException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ResourceNotFoundExceptionRes(parsedOutput);
-};
-const de_SubscribeToShardEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_SubscribeToShardEvent(data, context));
-    return contents;
-};
-const se_GetShardIteratorInput = (input, context) => {
-    return smithyClient.take(input, {
-        ShardId: [],
-        ShardIteratorType: [],
-        StartingSequenceNumber: [],
-        StreamARN: [],
-        StreamName: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_ListShardsInput = (input, context) => {
-    return smithyClient.take(input, {
-        ExclusiveStartShardId: [],
-        MaxResults: [],
-        NextToken: [],
-        ShardFilter: (_) => se_ShardFilter(_),
-        StreamARN: [],
-        StreamCreationTimestamp: (_) => _.getTime() / 1_000,
-        StreamName: [],
-    });
-};
-const se_ListStreamConsumersInput = (input, context) => {
-    return smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        StreamARN: [],
-        StreamCreationTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_PutRecordInput = (input, context) => {
-    return smithyClient.take(input, {
-        Data: context.base64Encoder,
-        ExplicitHashKey: [],
-        PartitionKey: [],
-        SequenceNumberForOrdering: [],
-        StreamARN: [],
-        StreamName: [],
-    });
-};
-const se_PutRecordsInput = (input, context) => {
-    return smithyClient.take(input, {
-        Records: (_) => se_PutRecordsRequestEntryList(_, context),
-        StreamARN: [],
-        StreamName: [],
-    });
-};
-const se_PutRecordsRequestEntry = (input, context) => {
-    return smithyClient.take(input, {
-        Data: context.base64Encoder,
-        ExplicitHashKey: [],
-        PartitionKey: [],
-    });
-};
-const se_PutRecordsRequestEntryList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_PutRecordsRequestEntry(entry, context);
-    });
-};
-const se_ShardFilter = (input, context) => {
-    return smithyClient.take(input, {
-        ShardId: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-        Type: [],
-    });
-};
-const se_StartingPosition = (input, context) => {
-    return smithyClient.take(input, {
-        SequenceNumber: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-        Type: [],
-    });
-};
-const se_SubscribeToShardInput = (input, context) => {
-    return smithyClient.take(input, {
-        ConsumerARN: [],
-        ShardId: [],
-        StartingPosition: (_) => se_StartingPosition(_),
-    });
-};
-const de_Consumer = (output, context) => {
-    return smithyClient.take(output, {
-        ConsumerARN: smithyClient.expectString,
-        ConsumerCreationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ConsumerName: smithyClient.expectString,
-        ConsumerStatus: smithyClient.expectString,
-    });
-};
-const de_ConsumerDescription = (output, context) => {
-    return smithyClient.take(output, {
-        ConsumerARN: smithyClient.expectString,
-        ConsumerCreationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ConsumerName: smithyClient.expectString,
-        ConsumerStatus: smithyClient.expectString,
-        StreamARN: smithyClient.expectString,
-    });
-};
-const de_ConsumerList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Consumer(entry);
-    });
-    return retVal;
-};
-const de_DescribeAccountSettingsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        MinimumThroughputBillingCommitment: (_) => de_MinimumThroughputBillingCommitmentOutput(_),
-    });
-};
-const de_DescribeStreamConsumerOutput = (output, context) => {
-    return smithyClient.take(output, {
-        ConsumerDescription: (_) => de_ConsumerDescription(_),
-    });
-};
-const de_DescribeStreamOutput = (output, context) => {
-    return smithyClient.take(output, {
-        StreamDescription: (_) => de_StreamDescription(_),
-    });
-};
-const de_DescribeStreamSummaryOutput = (output, context) => {
-    return smithyClient.take(output, {
-        StreamDescriptionSummary: (_) => de_StreamDescriptionSummary(_),
-    });
-};
-const de_GetRecordsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        ChildShards: smithyClient._json,
-        MillisBehindLatest: smithyClient.expectLong,
-        NextShardIterator: smithyClient.expectString,
-        Records: (_) => de_RecordList(_, context),
-    });
-};
-const de_ListStreamConsumersOutput = (output, context) => {
-    return smithyClient.take(output, {
-        Consumers: (_) => de_ConsumerList(_),
-        NextToken: smithyClient.expectString,
-    });
-};
-const de_ListStreamsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        HasMoreStreams: smithyClient.expectBoolean,
-        NextToken: smithyClient.expectString,
-        StreamNames: smithyClient._json,
-        StreamSummaries: (_) => de_StreamSummaryList(_),
-    });
-};
-const de_MinimumThroughputBillingCommitmentOutput = (output, context) => {
-    return smithyClient.take(output, {
-        EarliestAllowedEndAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        EndedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-    });
-};
-const de__Record = (output, context) => {
-    return smithyClient.take(output, {
-        ApproximateArrivalTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Data: context.base64Decoder,
-        EncryptionType: smithyClient.expectString,
-        PartitionKey: smithyClient.expectString,
-        SequenceNumber: smithyClient.expectString,
-    });
-};
-const de_RecordList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de__Record(entry, context);
-    });
-    return retVal;
-};
-const de_RegisterStreamConsumerOutput = (output, context) => {
-    return smithyClient.take(output, {
-        Consumer: (_) => de_Consumer(_),
-    });
-};
-const de_StreamDescription = (output, context) => {
-    return smithyClient.take(output, {
-        EncryptionType: smithyClient.expectString,
-        EnhancedMonitoring: smithyClient._json,
-        HasMoreShards: smithyClient.expectBoolean,
-        KeyId: smithyClient.expectString,
-        RetentionPeriodHours: smithyClient.expectInt32,
-        Shards: smithyClient._json,
-        StreamARN: smithyClient.expectString,
-        StreamCreationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamModeDetails: smithyClient._json,
-        StreamName: smithyClient.expectString,
-        StreamStatus: smithyClient.expectString,
-    });
-};
-const de_StreamDescriptionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        ConsumerCount: smithyClient.expectInt32,
-        EncryptionType: smithyClient.expectString,
-        EnhancedMonitoring: smithyClient._json,
-        KeyId: smithyClient.expectString,
-        MaxRecordSizeInKiB: smithyClient.expectInt32,
-        OpenShardCount: smithyClient.expectInt32,
-        RetentionPeriodHours: smithyClient.expectInt32,
-        StreamARN: smithyClient.expectString,
-        StreamCreationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamModeDetails: smithyClient._json,
-        StreamName: smithyClient.expectString,
-        StreamStatus: smithyClient.expectString,
-        WarmThroughput: smithyClient._json,
-    });
-};
-const de_StreamSummary = (output, context) => {
-    return smithyClient.take(output, {
-        StreamARN: smithyClient.expectString,
-        StreamCreationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamModeDetails: smithyClient._json,
-        StreamName: smithyClient.expectString,
-        StreamStatus: smithyClient.expectString,
-    });
-};
-const de_StreamSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StreamSummary(entry);
-    });
-    return retVal;
-};
-const de_SubscribeToShardEvent = (output, context) => {
-    return smithyClient.take(output, {
-        ChildShards: smithyClient._json,
-        ContinuationSequenceNumber: smithyClient.expectString,
-        MillisBehindLatest: smithyClient.expectLong,
-        Records: (_) => de_RecordList(_, context),
-    });
-};
-const de_UpdateAccountSettingsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        MinimumThroughputBillingCommitment: (_) => de_MinimumThroughputBillingCommitmentOutput(_),
-    });
-};
-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 throwDefaultError = smithyClient.withBaseException(KinesisServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `Kinesis_20131202.${operation}`,
-    };
-}
+const _AAT = "ApproximateArrivalTimestamp";
+const _ADE = "AccessDeniedException";
+const _APSI = "AdjacentParentShardId";
+const _ASTM = "AdjacentShardToMerge";
+const _ATTS = "AddTagsToStream";
+const _ATTSI = "AddTagsToStreamInput";
+const _C = "Consumer";
+const _CARN = "ConsumerARN";
+const _CC = "ConsumerCount";
+const _CCT = "ConsumerCreationTimestamp";
+const _CD = "ConsumerDescription";
+const _CL = "ConsumerList";
+const _CMB = "CurrentMiBps";
+const _CN = "ConsumerName";
+const _CS = "ChildShard";
+const _CSC = "CurrentShardCount";
+const _CSI = "CreateStreamInput";
+const _CSL = "ChildShardList";
+const _CSLM = "CurrentShardLevelMetrics";
+const _CSN = "ContinuationSequenceNumber";
+const _CSh = "ChildShards";
+const _CSo = "ConsumerStatus";
+const _CSr = "CreateStream";
+const _Co = "Consumers";
+const _D = "Data";
+const _DAS = "DescribeAccountSettings";
+const _DASI = "DescribeAccountSettingsInput";
+const _DASO = "DescribeAccountSettingsOutput";
+const _DEM = "DisableEnhancedMonitoring";
+const _DEMI = "DisableEnhancedMonitoringInput";
+const _DL = "DescribeLimits";
+const _DLI = "DescribeLimitsInput";
+const _DLO = "DescribeLimitsOutput";
+const _DRP = "DeleteResourcePolicy";
+const _DRPI = "DeleteResourcePolicyInput";
+const _DS = "DeleteStream";
+const _DSC = "DeregisterStreamConsumer";
+const _DSCI = "DeregisterStreamConsumerInput";
+const _DSCIe = "DescribeStreamConsumerInput";
+const _DSCO = "DescribeStreamConsumerOutput";
+const _DSCe = "DescribeStreamConsumer";
+const _DSI = "DeleteStreamInput";
+const _DSIe = "DescribeStreamInput";
+const _DSLM = "DesiredShardLevelMetrics";
+const _DSO = "DescribeStreamOutput";
+const _DSRP = "DecreaseStreamRetentionPeriod";
+const _DSRPI = "DecreaseStreamRetentionPeriodInput";
+const _DSS = "DescribeStreamSummary";
+const _DSSI = "DescribeStreamSummaryInput";
+const _DSSO = "DescribeStreamSummaryOutput";
+const _DSe = "DescribeStream";
+const _EA = "EndedAt";
+const _EAEA = "EarliestAllowedEndAt";
+const _EC = "ErrorCode";
+const _ECD = "EnforceConsumerDeletion";
+const _EEM = "EnableEnhancedMonitoring";
+const _EEMI = "EnableEnhancedMonitoringInput";
+const _EHK = "EndingHashKey";
+const _EHKx = "ExplicitHashKey";
+const _EIE = "ExpiredIteratorException";
+const _EM = "EnhancedMetrics";
+const _EML = "EnhancedMonitoringList";
+const _EMO = "EnhancedMonitoringOutput";
+const _EMn = "EnhancedMonitoring";
+const _EMr = "ErrorMessage";
+const _ENTE = "ExpiredNextTokenException";
+const _ES = "EventStream";
+const _ESN = "EndingSequenceNumber";
+const _ESSI = "ExclusiveStartShardId";
+const _ESSN = "ExclusiveStartStreamName";
+const _ESTK = "ExclusiveStartTagKey";
+const _ET = "EncryptionType";
+const _FRC = "FailedRecordCount";
+const _GR = "GetRecords";
+const _GRI = "GetRecordsInput";
+const _GRO = "GetRecordsOutput";
+const _GRP = "GetResourcePolicy";
+const _GRPI = "GetResourcePolicyInput";
+const _GRPO = "GetResourcePolicyOutput";
+const _GSI = "GetShardIterator";
+const _GSII = "GetShardIteratorInput";
+const _GSIO = "GetShardIteratorOutput";
+const _HKR = "HashKeyRange";
+const _HMS = "HasMoreStreams";
+const _HMSa = "HasMoreShards";
+const _HMT = "HasMoreTags";
+const _IAE = "InvalidArgumentException";
+const _IFE = "InternalFailureException";
+const _ISRP = "IncreaseStreamRetentionPeriod";
+const _ISRPI = "IncreaseStreamRetentionPeriodInput";
+const _K = "Key";
+const _KI = "KeyId";
+const _KMSADE = "KMSAccessDeniedException";
+const _KMSDE = "KMSDisabledException";
+const _KMSISE = "KMSInvalidStateException";
+const _KMSNFE = "KMSNotFoundException";
+const _KMSOIR = "KMSOptInRequired";
+const _KMSTE = "KMSThrottlingException";
+const _L = "Limit";
+const _LEE = "LimitExceededException";
+const _LS = "ListShards";
+const _LSC = "ListStreamConsumers";
+const _LSCI = "ListStreamConsumersInput";
+const _LSCO = "ListStreamConsumersOutput";
+const _LSI = "ListShardsInput";
+const _LSIi = "ListStreamsInput";
+const _LSO = "ListShardsOutput";
+const _LSOi = "ListStreamsOutput";
+const _LSi = "ListStreams";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LTFS = "ListTagsForStream";
+const _LTFSI = "ListTagsForStreamInput";
+const _LTFSO = "ListTagsForStreamOutput";
+const _MBL = "MillisBehindLatest";
+const _MR = "MaxResults";
+const _MRSIKB = "MaxRecordSizeInKiB";
+const _MS = "MergeShards";
+const _MSI = "MergeShardsInput";
+const _MTBC = "MinimumThroughputBillingCommitment";
+const _MTBCI = "MinimumThroughputBillingCommitmentInput";
+const _MTBCO = "MinimumThroughputBillingCommitmentOutput";
+const _NSHK = "NewStartingHashKey";
+const _NSI = "NextShardIterator";
+const _NT = "NextToken";
+const _ODSC = "OnDemandStreamCount";
+const _ODSCL = "OnDemandStreamCountLimit";
+const _OSC = "OpenShardCount";
+const _P = "Policy";
+const _PK = "PartitionKey";
+const _PR = "PutRecord";
+const _PRI = "PutRecordInput";
+const _PRIu = "PutRecordsInput";
+const _PRO = "PutRecordOutput";
+const _PROu = "PutRecordsOutput";
+const _PRP = "PutResourcePolicy";
+const _PRPI = "PutResourcePolicyInput";
+const _PRRE = "PutRecordsRequestEntry";
+const _PRREL = "PutRecordsRequestEntryList";
+const _PRRELu = "PutRecordsResultEntryList";
+const _PRREu = "PutRecordsResultEntry";
+const _PRu = "PutRecords";
+const _PS = "ParentShards";
+const _PSI = "ParentShardId";
+const _PTEE = "ProvisionedThroughputExceededException";
+const _R = "Records";
+const _RARN = "ResourceARN";
+const _RIUE = "ResourceInUseException";
+const _RL = "RecordList";
+const _RNFE = "ResourceNotFoundException";
+const _RPH = "RetentionPeriodHours";
+const _RSC = "RegisterStreamConsumer";
+const _RSCI = "RegisterStreamConsumerInput";
+const _RSCO = "RegisterStreamConsumerOutput";
+const _RTFS = "RemoveTagsFromStream";
+const _RTFSI = "RemoveTagsFromStreamInput";
+const _Re = "Record";
+const _S = "Shards";
+const _SA = "StartedAt";
+const _SARN = "StreamARN";
+const _SC = "ShardCount";
+const _SCT = "StreamCreationTimestamp";
+const _SD = "StreamDescription";
+const _SDS = "StreamDescriptionSummary";
+const _SF = "ShardFilter";
+const _SHK = "StartingHashKey";
+const _SI = "ShardId";
+const _SIT = "ShardIteratorType";
+const _SIh = "ShardIterator";
+const _SL = "ShardLimit";
+const _SLM = "ShardLevelMetrics";
+const _SLh = "ShardList";
+const _SM = "StreamMode";
+const _SMD = "StreamModeDetails";
+const _SN = "StreamName";
+const _SNFO = "SequenceNumberForOrdering";
+const _SNR = "SequenceNumberRange";
+const _SNe = "SequenceNumber";
+const _SNt = "StreamNames";
+const _SP = "StartingPosition";
+const _SS = "StreamSummaries";
+const _SSE = "StartStreamEncryption";
+const _SSEI = "StartStreamEncryptionInput";
+const _SSEIt = "StopStreamEncryptionInput";
+const _SSEt = "StopStreamEncryption";
+const _SSI = "SplitShardInput";
+const _SSL = "StreamSummaryList";
+const _SSN = "StartingSequenceNumber";
+const _SSp = "SplitShard";
+const _SSt = "StreamStatus";
+const _SStr = "StreamSummary";
+const _ST = "ScalingType";
+const _STM = "ShardToMerge";
+const _STS = "ShardToSplit";
+const _STSE = "SubscribeToShardEvent";
+const _STSES = "SubscribeToShardEventStream";
+const _STSI = "SubscribeToShardInput";
+const _STSO = "SubscribeToShardOutput";
+const _STSu = "SubscribeToShard";
+const _Sh = "Shard";
+const _St = "Status";
+const _T = "Tags";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TMB = "TargetMiBps";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TSC = "TargetShardCount";
+const _Ta = "Tag";
+const _Ti = "Timestamp";
+const _Ty = "Type";
+const _UAS = "UpdateAccountSettings";
+const _UASI = "UpdateAccountSettingsInput";
+const _UASO = "UpdateAccountSettingsOutput";
+const _UMRS = "UpdateMaxRecordSize";
+const _UMRSI = "UpdateMaxRecordSizeInput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _USC = "UpdateShardCount";
+const _USCI = "UpdateShardCountInput";
+const _USCO = "UpdateShardCountOutput";
+const _USM = "UpdateStreamMode";
+const _USMI = "UpdateStreamModeInput";
+const _USWT = "UpdateStreamWarmThroughput";
+const _USWTI = "UpdateStreamWarmThroughputInput";
+const _USWTO = "UpdateStreamWarmThroughputOutput";
+const _V = "Value";
+const _VE = "ValidationException";
+const _WT = "WarmThroughput";
+const _WTMB = "WarmThroughputMiBps";
+const _WTO = "WarmThroughputObject";
+const _c = "client";
+const _e = "error";
+const _m = "message";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.kinesis";
+const _st = "streaming";
+const n0 = "com.amazonaws.kinesis";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AddTagsToStreamInput = [3, n0, _ATTSI, 0, [_SN, _T, _SARN], [0, 128 | 0, 0]];
+var ChildShard = [3, n0, _CS, 0, [_SI, _PS, _HKR], [0, 64 | 0, () => HashKeyRange]];
+var Consumer = [3, n0, _C, 0, [_CN, _CARN, _CSo, _CCT], [0, 0, 0, 4]];
+var ConsumerDescription = [
+    3,
+    n0,
+    _CD,
+    0,
+    [_CN, _CARN, _CSo, _CCT, _SARN],
+    [0, 0, 0, 4, 0],
+];
+var CreateStreamInput = [
+    3,
+    n0,
+    _CSI,
+    0,
+    [_SN, _SC, _SMD, _T, _WTMB, _MRSIKB],
+    [0, 1, () => StreamModeDetails, 128 | 0, 1, 1],
+];
+var DecreaseStreamRetentionPeriodInput = [
+    3,
+    n0,
+    _DSRPI,
+    0,
+    [_SN, _RPH, _SARN],
+    [0, 1, 0],
+];
+var DeleteResourcePolicyInput = [3, n0, _DRPI, 0, [_RARN], [0]];
+var DeleteStreamInput = [3, n0, _DSI, 0, [_SN, _ECD, _SARN], [0, 2, 0]];
+var DeregisterStreamConsumerInput = [3, n0, _DSCI, 0, [_SARN, _CN, _CARN], [0, 0, 0]];
+var DescribeAccountSettingsInput = [3, n0, _DASI, 0, [], []];
+var DescribeAccountSettingsOutput = [
+    3,
+    n0,
+    _DASO,
+    0,
+    [_MTBC],
+    [() => MinimumThroughputBillingCommitmentOutput],
+];
+var DescribeLimitsInput = [3, n0, _DLI, 0, [], []];
+var DescribeLimitsOutput = [3, n0, _DLO, 0, [_SL, _OSC, _ODSC, _ODSCL], [1, 1, 1, 1]];
+var DescribeStreamConsumerInput = [3, n0, _DSCIe, 0, [_SARN, _CN, _CARN], [0, 0, 0]];
+var DescribeStreamConsumerOutput = [3, n0, _DSCO, 0, [_CD], [() => ConsumerDescription]];
+var DescribeStreamInput = [3, n0, _DSIe, 0, [_SN, _L, _ESSI, _SARN], [0, 1, 0, 0]];
+var DescribeStreamOutput = [3, n0, _DSO, 0, [_SD], [() => StreamDescription]];
+var DescribeStreamSummaryInput = [3, n0, _DSSI, 0, [_SN, _SARN], [0, 0]];
+var DescribeStreamSummaryOutput = [
+    3,
+    n0,
+    _DSSO,
+    0,
+    [_SDS],
+    [() => StreamDescriptionSummary],
+];
+var DisableEnhancedMonitoringInput = [
+    3,
+    n0,
+    _DEMI,
+    0,
+    [_SN, _SLM, _SARN],
+    [0, 64 | 0, 0],
+];
+var EnableEnhancedMonitoringInput = [3, n0, _EEMI, 0, [_SN, _SLM, _SARN], [0, 64 | 0, 0]];
+var EnhancedMetrics = [3, n0, _EM, 0, [_SLM], [64 | 0]];
+var EnhancedMonitoringOutput = [
+    3,
+    n0,
+    _EMO,
+    0,
+    [_SN, _CSLM, _DSLM, _SARN],
+    [0, 64 | 0, 64 | 0, 0],
+];
+var ExpiredIteratorException = [
+    -3,
+    n0,
+    _EIE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExpiredIteratorException, ExpiredIteratorException$1);
+var ExpiredNextTokenException = [
+    -3,
+    n0,
+    _ENTE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExpiredNextTokenException, ExpiredNextTokenException$1);
+var GetRecordsInput = [3, n0, _GRI, 0, [_SIh, _L, _SARN], [0, 1, 0]];
+var GetRecordsOutput = [
+    3,
+    n0,
+    _GRO,
+    0,
+    [_R, _NSI, _MBL, _CSh],
+    [() => RecordList, 0, 1, () => ChildShardList],
+];
+var GetResourcePolicyInput = [3, n0, _GRPI, 0, [_RARN], [0]];
+var GetResourcePolicyOutput = [3, n0, _GRPO, 0, [_P], [0]];
+var GetShardIteratorInput = [
+    3,
+    n0,
+    _GSII,
+    0,
+    [_SN, _SI, _SIT, _SSN, _Ti, _SARN],
+    [0, 0, 0, 0, 4, 0],
+];
+var GetShardIteratorOutput = [3, n0, _GSIO, 0, [_SIh], [0]];
+var HashKeyRange = [3, n0, _HKR, 0, [_SHK, _EHK], [0, 0]];
+var IncreaseStreamRetentionPeriodInput = [
+    3,
+    n0,
+    _ISRPI,
+    0,
+    [_SN, _RPH, _SARN],
+    [0, 1, 0],
+];
+var InternalFailureException = [
+    -3,
+    n0,
+    _IFE,
+    {
+        [_e]: _s,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailureException, InternalFailureException$1);
+var InvalidArgumentException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArgumentException, InvalidArgumentException$1);
+var KMSAccessDeniedException = [
+    -3,
+    n0,
+    _KMSADE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSAccessDeniedException, KMSAccessDeniedException$1);
+var KMSDisabledException = [
+    -3,
+    n0,
+    _KMSDE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSDisabledException, KMSDisabledException$1);
+var KMSInvalidStateException = [
+    -3,
+    n0,
+    _KMSISE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSInvalidStateException, KMSInvalidStateException$1);
+var KMSNotFoundException = [
+    -3,
+    n0,
+    _KMSNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSNotFoundException, KMSNotFoundException$1);
+var KMSOptInRequired = [
+    -3,
+    n0,
+    _KMSOIR,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSOptInRequired, KMSOptInRequired$1);
+var KMSThrottlingException = [
+    -3,
+    n0,
+    _KMSTE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KMSThrottlingException, KMSThrottlingException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListShardsInput = [
+    3,
+    n0,
+    _LSI,
+    0,
+    [_SN, _NT, _ESSI, _MR, _SCT, _SF, _SARN],
+    [0, 0, 0, 1, 4, () => ShardFilter, 0],
+];
+var ListShardsOutput = [3, n0, _LSO, 0, [_S, _NT], [() => ShardList, 0]];
+var ListStreamConsumersInput = [3, n0, _LSCI, 0, [_SARN, _NT, _MR, _SCT], [0, 0, 1, 4]];
+var ListStreamConsumersOutput = [3, n0, _LSCO, 0, [_Co, _NT], [() => ConsumerList, 0]];
+var ListStreamsInput = [3, n0, _LSIi, 0, [_L, _ESSN, _NT], [1, 0, 0]];
+var ListStreamsOutput = [
+    3,
+    n0,
+    _LSOi,
+    0,
+    [_SNt, _HMS, _NT, _SS],
+    [64 | 0, 2, 0, () => StreamSummaryList],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_RARN], [0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_T], [() => TagList]];
+var ListTagsForStreamInput = [3, n0, _LTFSI, 0, [_SN, _ESTK, _L, _SARN], [0, 0, 1, 0]];
+var ListTagsForStreamOutput = [3, n0, _LTFSO, 0, [_T, _HMT], [() => TagList, 2]];
+var MergeShardsInput = [3, n0, _MSI, 0, [_SN, _STM, _ASTM, _SARN], [0, 0, 0, 0]];
+var MinimumThroughputBillingCommitmentInput = [3, n0, _MTBCI, 0, [_St], [0]];
+var MinimumThroughputBillingCommitmentOutput = [
+    3,
+    n0,
+    _MTBCO,
+    0,
+    [_St, _SA, _EA, _EAEA],
+    [0, 4, 4, 4],
+];
+var ProvisionedThroughputExceededException = [
+    -3,
+    n0,
+    _PTEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ProvisionedThroughputExceededException, ProvisionedThroughputExceededException$1);
+var PutRecordInput = [
+    3,
+    n0,
+    _PRI,
+    0,
+    [_SN, _D, _PK, _EHKx, _SNFO, _SARN],
+    [0, 21, 0, 0, 0, 0],
+];
+var PutRecordOutput = [3, n0, _PRO, 0, [_SI, _SNe, _ET], [0, 0, 0]];
+var PutRecordsInput = [
+    3,
+    n0,
+    _PRIu,
+    0,
+    [_R, _SN, _SARN],
+    [() => PutRecordsRequestEntryList, 0, 0],
+];
+var PutRecordsOutput = [
+    3,
+    n0,
+    _PROu,
+    0,
+    [_FRC, _R, _ET],
+    [1, () => PutRecordsResultEntryList, 0],
+];
+var PutRecordsRequestEntry = [3, n0, _PRRE, 0, [_D, _EHKx, _PK], [21, 0, 0]];
+var PutRecordsResultEntry = [3, n0, _PRREu, 0, [_SNe, _SI, _EC, _EMr], [0, 0, 0, 0]];
+var PutResourcePolicyInput = [3, n0, _PRPI, 0, [_RARN, _P], [0, 0]];
+var _Record = [3, n0, _Re, 0, [_SNe, _AAT, _D, _PK, _ET], [0, 4, 21, 0, 0]];
+var RegisterStreamConsumerInput = [3, n0, _RSCI, 0, [_SARN, _CN, _T], [0, 0, 128 | 0]];
+var RegisterStreamConsumerOutput = [3, n0, _RSCO, 0, [_C], [() => Consumer]];
+var RemoveTagsFromStreamInput = [3, n0, _RTFSI, 0, [_SN, _TK, _SARN], [0, 64 | 0, 0]];
+var ResourceInUseException = [
+    -3,
+    n0,
+    _RIUE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceInUseException, ResourceInUseException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SequenceNumberRange = [3, n0, _SNR, 0, [_SSN, _ESN], [0, 0]];
+var Shard = [
+    3,
+    n0,
+    _Sh,
+    0,
+    [_SI, _PSI, _APSI, _HKR, _SNR],
+    [0, 0, 0, () => HashKeyRange, () => SequenceNumberRange],
+];
+var ShardFilter = [3, n0, _SF, 0, [_Ty, _SI, _Ti], [0, 0, 4]];
+var SplitShardInput = [3, n0, _SSI, 0, [_SN, _STS, _NSHK, _SARN], [0, 0, 0, 0]];
+var StartingPosition = [3, n0, _SP, 0, [_Ty, _SNe, _Ti], [0, 0, 4]];
+var StartStreamEncryptionInput = [3, n0, _SSEI, 0, [_SN, _ET, _KI, _SARN], [0, 0, 0, 0]];
+var StopStreamEncryptionInput = [3, n0, _SSEIt, 0, [_SN, _ET, _KI, _SARN], [0, 0, 0, 0]];
+var StreamDescription = [
+    3,
+    n0,
+    _SD,
+    0,
+    [_SN, _SARN, _SSt, _SMD, _S, _HMSa, _RPH, _SCT, _EMn, _ET, _KI],
+    [0, 0, 0, () => StreamModeDetails, () => ShardList, 2, 1, 4, () => EnhancedMonitoringList, 0, 0],
+];
+var StreamDescriptionSummary = [
+    3,
+    n0,
+    _SDS,
+    0,
+    [_SN, _SARN, _SSt, _SMD, _RPH, _SCT, _EMn, _ET, _KI, _OSC, _CC, _WT, _MRSIKB],
+    [0, 0, 0, () => StreamModeDetails, 1, 4, () => EnhancedMonitoringList, 0, 0, 1, 1, () => WarmThroughputObject, 1],
+];
+var StreamModeDetails = [3, n0, _SMD, 0, [_SM], [0]];
+var StreamSummary = [
+    3,
+    n0,
+    _SStr,
+    0,
+    [_SN, _SARN, _SSt, _SMD, _SCT],
+    [0, 0, 0, () => StreamModeDetails, 4],
+];
+var SubscribeToShardEvent = [
+    3,
+    n0,
+    _STSE,
+    0,
+    [_R, _CSN, _MBL, _CSh],
+    [() => RecordList, 0, 1, () => ChildShardList],
+];
+var SubscribeToShardInput = [
+    3,
+    n0,
+    _STSI,
+    0,
+    [_CARN, _SI, _SP],
+    [0, 0, () => StartingPosition],
+];
+var SubscribeToShardOutput = [
+    3,
+    n0,
+    _STSO,
+    0,
+    [_ES],
+    [[() => SubscribeToShardEventStream, 0]],
+];
+var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_T, _RARN], [128 | 0, 0]];
+var UntagResourceInput = [3, n0, _URI, 0, [_TK, _RARN], [64 | 0, 0]];
+var UpdateAccountSettingsInput = [
+    3,
+    n0,
+    _UASI,
+    0,
+    [_MTBC],
+    [() => MinimumThroughputBillingCommitmentInput],
+];
+var UpdateAccountSettingsOutput = [
+    3,
+    n0,
+    _UASO,
+    0,
+    [_MTBC],
+    [() => MinimumThroughputBillingCommitmentOutput],
+];
+var UpdateMaxRecordSizeInput = [3, n0, _UMRSI, 0, [_SARN, _MRSIKB], [0, 1]];
+var UpdateShardCountInput = [3, n0, _USCI, 0, [_SN, _TSC, _ST, _SARN], [0, 1, 0, 0]];
+var UpdateShardCountOutput = [3, n0, _USCO, 0, [_SN, _CSC, _TSC, _SARN], [0, 1, 1, 0]];
+var UpdateStreamModeInput = [
+    3,
+    n0,
+    _USMI,
+    0,
+    [_SARN, _SMD, _WTMB],
+    [0, () => StreamModeDetails, 1],
+];
+var UpdateStreamWarmThroughputInput = [3, n0, _USWTI, 0, [_SARN, _SN, _WTMB], [0, 0, 1]];
+var UpdateStreamWarmThroughputOutput = [
+    3,
+    n0,
+    _USWTO,
+    0,
+    [_SARN, _SN, _WT],
+    [0, 0, () => WarmThroughputObject],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var WarmThroughputObject = [3, n0, _WTO, 0, [_TMB, _CMB], [1, 1]];
+var __Unit = "unit";
+var KinesisServiceException = [-3, _sm, "KinesisServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(KinesisServiceException, KinesisServiceException$1);
+var ChildShardList = [1, n0, _CSL, 0, () => ChildShard];
+var ConsumerList = [1, n0, _CL, 0, () => Consumer];
+var EnhancedMonitoringList = [1, n0, _EML, 0, () => EnhancedMetrics];
+var PutRecordsRequestEntryList = [1, n0, _PRREL, 0, () => PutRecordsRequestEntry];
+var PutRecordsResultEntryList = [1, n0, _PRRELu, 0, () => PutRecordsResultEntry];
+var RecordList = [1, n0, _RL, 0, () => _Record];
+var ShardList = [1, n0, _SLh, 0, () => Shard];
+var StreamSummaryList = [1, n0, _SSL, 0, () => StreamSummary];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var SubscribeToShardEventStream = [
+    3,
+    n0,
+    _STSES,
+    {
+        [_st]: 1,
+    },
+    [_STSE, _RNFE, _RIUE, _KMSDE, _KMSISE, _KMSADE, _KMSNFE, _KMSOIR, _KMSTE, _IFE],
+    [
+        () => SubscribeToShardEvent,
+        [() => ResourceNotFoundException, 0],
+        [() => ResourceInUseException, 0],
+        [() => KMSDisabledException, 0],
+        [() => KMSInvalidStateException, 0],
+        [() => KMSAccessDeniedException, 0],
+        [() => KMSNotFoundException, 0],
+        [() => KMSOptInRequired, 0],
+        [() => KMSThrottlingException, 0],
+        [() => InternalFailureException, 0],
+    ],
+];
+var AddTagsToStream = [9, n0, _ATTS, 0, () => AddTagsToStreamInput, () => __Unit];
+var CreateStream = [9, n0, _CSr, 0, () => CreateStreamInput, () => __Unit];
+var DecreaseStreamRetentionPeriod = [
+    9,
+    n0,
+    _DSRP,
+    0,
+    () => DecreaseStreamRetentionPeriodInput,
+    () => __Unit,
+];
+var DeleteResourcePolicy = [
+    9,
+    n0,
+    _DRP,
+    0,
+    () => DeleteResourcePolicyInput,
+    () => __Unit,
+];
+var DeleteStream = [9, n0, _DS, 0, () => DeleteStreamInput, () => __Unit];
+var DeregisterStreamConsumer = [
+    9,
+    n0,
+    _DSC,
+    0,
+    () => DeregisterStreamConsumerInput,
+    () => __Unit,
+];
+var DescribeAccountSettings = [
+    9,
+    n0,
+    _DAS,
+    0,
+    () => DescribeAccountSettingsInput,
+    () => DescribeAccountSettingsOutput,
+];
+var DescribeLimits = [
+    9,
+    n0,
+    _DL,
+    0,
+    () => DescribeLimitsInput,
+    () => DescribeLimitsOutput,
+];
+var DescribeStream = [
+    9,
+    n0,
+    _DSe,
+    0,
+    () => DescribeStreamInput,
+    () => DescribeStreamOutput,
+];
+var DescribeStreamConsumer = [
+    9,
+    n0,
+    _DSCe,
+    0,
+    () => DescribeStreamConsumerInput,
+    () => DescribeStreamConsumerOutput,
+];
+var DescribeStreamSummary = [
+    9,
+    n0,
+    _DSS,
+    0,
+    () => DescribeStreamSummaryInput,
+    () => DescribeStreamSummaryOutput,
+];
+var DisableEnhancedMonitoring = [
+    9,
+    n0,
+    _DEM,
+    0,
+    () => DisableEnhancedMonitoringInput,
+    () => EnhancedMonitoringOutput,
+];
+var EnableEnhancedMonitoring = [
+    9,
+    n0,
+    _EEM,
+    0,
+    () => EnableEnhancedMonitoringInput,
+    () => EnhancedMonitoringOutput,
+];
+var GetRecords = [9, n0, _GR, 0, () => GetRecordsInput, () => GetRecordsOutput];
+var GetResourcePolicy = [
+    9,
+    n0,
+    _GRP,
+    0,
+    () => GetResourcePolicyInput,
+    () => GetResourcePolicyOutput,
+];
+var GetShardIterator = [
+    9,
+    n0,
+    _GSI,
+    0,
+    () => GetShardIteratorInput,
+    () => GetShardIteratorOutput,
+];
+var IncreaseStreamRetentionPeriod = [
+    9,
+    n0,
+    _ISRP,
+    0,
+    () => IncreaseStreamRetentionPeriodInput,
+    () => __Unit,
+];
+var ListShards = [9, n0, _LS, 0, () => ListShardsInput, () => ListShardsOutput];
+var ListStreamConsumers = [
+    9,
+    n0,
+    _LSC,
+    0,
+    () => ListStreamConsumersInput,
+    () => ListStreamConsumersOutput,
+];
+var ListStreams = [9, n0, _LSi, 0, () => ListStreamsInput, () => ListStreamsOutput];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var ListTagsForStream = [
+    9,
+    n0,
+    _LTFS,
+    0,
+    () => ListTagsForStreamInput,
+    () => ListTagsForStreamOutput,
+];
+var MergeShards = [9, n0, _MS, 0, () => MergeShardsInput, () => __Unit];
+var PutRecord = [9, n0, _PR, 0, () => PutRecordInput, () => PutRecordOutput];
+var PutRecords = [9, n0, _PRu, 0, () => PutRecordsInput, () => PutRecordsOutput];
+var PutResourcePolicy = [9, n0, _PRP, 0, () => PutResourcePolicyInput, () => __Unit];
+var RegisterStreamConsumer = [
+    9,
+    n0,
+    _RSC,
+    0,
+    () => RegisterStreamConsumerInput,
+    () => RegisterStreamConsumerOutput,
+];
+var RemoveTagsFromStream = [
+    9,
+    n0,
+    _RTFS,
+    0,
+    () => RemoveTagsFromStreamInput,
+    () => __Unit,
+];
+var SplitShard = [9, n0, _SSp, 0, () => SplitShardInput, () => __Unit];
+var StartStreamEncryption = [
+    9,
+    n0,
+    _SSE,
+    0,
+    () => StartStreamEncryptionInput,
+    () => __Unit,
+];
+var StopStreamEncryption = [
+    9,
+    n0,
+    _SSEt,
+    0,
+    () => StopStreamEncryptionInput,
+    () => __Unit,
+];
+var SubscribeToShard = [
+    9,
+    n0,
+    _STSu,
+    0,
+    () => SubscribeToShardInput,
+    () => SubscribeToShardOutput,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceInput, () => __Unit];
+var UntagResource = [9, n0, _UR, 0, () => UntagResourceInput, () => __Unit];
+var UpdateAccountSettings = [
+    9,
+    n0,
+    _UAS,
+    0,
+    () => UpdateAccountSettingsInput,
+    () => UpdateAccountSettingsOutput,
+];
+var UpdateMaxRecordSize = [9, n0, _UMRS, 0, () => UpdateMaxRecordSizeInput, () => __Unit];
+var UpdateShardCount = [
+    9,
+    n0,
+    _USC,
+    0,
+    () => UpdateShardCountInput,
+    () => UpdateShardCountOutput,
+];
+var UpdateStreamMode = [9, n0, _USM, 0, () => UpdateStreamModeInput, () => __Unit];
+var UpdateStreamWarmThroughput = [
+    9,
+    n0,
+    _USWT,
+    0,
+    () => UpdateStreamWarmThroughputInput,
+    () => UpdateStreamWarmThroughputOutput,
+];
 
 class AddTagsToStreamCommand extends smithyClient.Command
     .classBuilder()
@@ -1720,16 +1329,11 @@ class AddTagsToStreamCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "AddTagsToStream", {})
     .n("KinesisClient", "AddTagsToStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_AddTagsToStreamCommand)
-    .de(de_AddTagsToStreamCommand)
+    .sc(AddTagsToStream)
     .build() {
 }
 
@@ -1737,16 +1341,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("Kinesis_20131202", "CreateStream", {})
     .n("KinesisClient", "CreateStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateStreamCommand)
-    .de(de_CreateStreamCommand)
+    .sc(CreateStream)
     .build() {
 }
 
@@ -1758,16 +1357,11 @@ class DecreaseStreamRetentionPeriodCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DecreaseStreamRetentionPeriod", {})
     .n("KinesisClient", "DecreaseStreamRetentionPeriodCommand")
-    .f(void 0, void 0)
-    .ser(se_DecreaseStreamRetentionPeriodCommand)
-    .de(de_DecreaseStreamRetentionPeriodCommand)
+    .sc(DecreaseStreamRetentionPeriod)
     .build() {
 }
 
@@ -1779,16 +1373,11 @@ class DeleteResourcePolicyCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "DeleteResourcePolicy", {})
     .n("KinesisClient", "DeleteResourcePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteResourcePolicyCommand)
-    .de(de_DeleteResourcePolicyCommand)
+    .sc(DeleteResourcePolicy)
     .build() {
 }
 
@@ -1800,16 +1389,11 @@ class DeleteStreamCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DeleteStream", {})
     .n("KinesisClient", "DeleteStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStreamCommand)
-    .de(de_DeleteStreamCommand)
+    .sc(DeleteStream)
     .build() {
 }
 
@@ -1822,16 +1406,11 @@ class DeregisterStreamConsumerCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DeregisterStreamConsumer", {})
     .n("KinesisClient", "DeregisterStreamConsumerCommand")
-    .f(void 0, void 0)
-    .ser(se_DeregisterStreamConsumerCommand)
-    .de(de_DeregisterStreamConsumerCommand)
+    .sc(DeregisterStreamConsumer)
     .build() {
 }
 
@@ -1839,16 +1418,11 @@ class DescribeAccountSettingsCommand 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("Kinesis_20131202", "DescribeAccountSettings", {})
     .n("KinesisClient", "DescribeAccountSettingsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeAccountSettingsCommand)
-    .de(de_DescribeAccountSettingsCommand)
+    .sc(DescribeAccountSettings)
     .build() {
 }
 
@@ -1856,16 +1430,11 @@ class DescribeLimitsCommand 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("Kinesis_20131202", "DescribeLimits", {})
     .n("KinesisClient", "DescribeLimitsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLimitsCommand)
-    .de(de_DescribeLimitsCommand)
+    .sc(DescribeLimits)
     .build() {
 }
 
@@ -1877,16 +1446,11 @@ class DescribeStreamCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DescribeStream", {})
     .n("KinesisClient", "DescribeStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeStreamCommand)
-    .de(de_DescribeStreamCommand)
+    .sc(DescribeStream)
     .build() {
 }
 
@@ -1899,16 +1463,11 @@ class DescribeStreamConsumerCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DescribeStreamConsumer", {})
     .n("KinesisClient", "DescribeStreamConsumerCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeStreamConsumerCommand)
-    .de(de_DescribeStreamConsumerCommand)
+    .sc(DescribeStreamConsumer)
     .build() {
 }
 
@@ -1920,16 +1479,11 @@ class DescribeStreamSummaryCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DescribeStreamSummary", {})
     .n("KinesisClient", "DescribeStreamSummaryCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeStreamSummaryCommand)
-    .de(de_DescribeStreamSummaryCommand)
+    .sc(DescribeStreamSummary)
     .build() {
 }
 
@@ -1941,16 +1495,11 @@ class DisableEnhancedMonitoringCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "DisableEnhancedMonitoring", {})
     .n("KinesisClient", "DisableEnhancedMonitoringCommand")
-    .f(void 0, void 0)
-    .ser(se_DisableEnhancedMonitoringCommand)
-    .de(de_DisableEnhancedMonitoringCommand)
+    .sc(DisableEnhancedMonitoring)
     .build() {
 }
 
@@ -1962,16 +1511,11 @@ class EnableEnhancedMonitoringCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "EnableEnhancedMonitoring", {})
     .n("KinesisClient", "EnableEnhancedMonitoringCommand")
-    .f(void 0, void 0)
-    .ser(se_EnableEnhancedMonitoringCommand)
-    .de(de_EnableEnhancedMonitoringCommand)
+    .sc(EnableEnhancedMonitoring)
     .build() {
 }
 
@@ -1983,16 +1527,11 @@ class GetRecordsCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "GetRecords", {})
     .n("KinesisClient", "GetRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRecordsCommand)
-    .de(de_GetRecordsCommand)
+    .sc(GetRecords)
     .build() {
 }
 
@@ -2004,16 +1543,11 @@ class GetResourcePolicyCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "GetResourcePolicy", {})
     .n("KinesisClient", "GetResourcePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetResourcePolicyCommand)
-    .de(de_GetResourcePolicyCommand)
+    .sc(GetResourcePolicy)
     .build() {
 }
 
@@ -2025,16 +1559,11 @@ class GetShardIteratorCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "GetShardIterator", {})
     .n("KinesisClient", "GetShardIteratorCommand")
-    .f(void 0, void 0)
-    .ser(se_GetShardIteratorCommand)
-    .de(de_GetShardIteratorCommand)
+    .sc(GetShardIterator)
     .build() {
 }
 
@@ -2046,16 +1575,11 @@ class IncreaseStreamRetentionPeriodCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "IncreaseStreamRetentionPeriod", {})
     .n("KinesisClient", "IncreaseStreamRetentionPeriodCommand")
-    .f(void 0, void 0)
-    .ser(se_IncreaseStreamRetentionPeriodCommand)
-    .de(de_IncreaseStreamRetentionPeriodCommand)
+    .sc(IncreaseStreamRetentionPeriod)
     .build() {
 }
 
@@ -2067,16 +1591,11 @@ class ListShardsCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "ListShards", {})
     .n("KinesisClient", "ListShardsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListShardsCommand)
-    .de(de_ListShardsCommand)
+    .sc(ListShards)
     .build() {
 }
 
@@ -2088,16 +1607,11 @@ class ListStreamConsumersCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "ListStreamConsumers", {})
     .n("KinesisClient", "ListStreamConsumersCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamConsumersCommand)
-    .de(de_ListStreamConsumersCommand)
+    .sc(ListStreamConsumers)
     .build() {
 }
 
@@ -2105,16 +1619,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("Kinesis_20131202", "ListStreams", {})
     .n("KinesisClient", "ListStreamsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamsCommand)
-    .de(de_ListStreamsCommand)
+    .sc(ListStreams)
     .build() {
 }
 
@@ -2126,16 +1635,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "ListTagsForResource", {})
     .n("KinesisClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2147,16 +1651,11 @@ class ListTagsForStreamCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "ListTagsForStream", {})
     .n("KinesisClient", "ListTagsForStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForStreamCommand)
-    .de(de_ListTagsForStreamCommand)
+    .sc(ListTagsForStream)
     .build() {
 }
 
@@ -2168,16 +1667,11 @@ class MergeShardsCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "MergeShards", {})
     .n("KinesisClient", "MergeShardsCommand")
-    .f(void 0, void 0)
-    .ser(se_MergeShardsCommand)
-    .de(de_MergeShardsCommand)
+    .sc(MergeShards)
     .build() {
 }
 
@@ -2189,16 +1683,11 @@ class PutRecordCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "PutRecord", {})
     .n("KinesisClient", "PutRecordCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRecordCommand)
-    .de(de_PutRecordCommand)
+    .sc(PutRecord)
     .build() {
 }
 
@@ -2210,16 +1699,11 @@ class PutRecordsCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "PutRecords", {})
     .n("KinesisClient", "PutRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRecordsCommand)
-    .de(de_PutRecordsCommand)
+    .sc(PutRecords)
     .build() {
 }
 
@@ -2231,16 +1715,11 @@ class PutResourcePolicyCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "PutResourcePolicy", {})
     .n("KinesisClient", "PutResourcePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_PutResourcePolicyCommand)
-    .de(de_PutResourcePolicyCommand)
+    .sc(PutResourcePolicy)
     .build() {
 }
 
@@ -2252,16 +1731,11 @@ class RegisterStreamConsumerCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "RegisterStreamConsumer", {})
     .n("KinesisClient", "RegisterStreamConsumerCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterStreamConsumerCommand)
-    .de(de_RegisterStreamConsumerCommand)
+    .sc(RegisterStreamConsumer)
     .build() {
 }
 
@@ -2273,16 +1747,11 @@ class RemoveTagsFromStreamCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "RemoveTagsFromStream", {})
     .n("KinesisClient", "RemoveTagsFromStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_RemoveTagsFromStreamCommand)
-    .de(de_RemoveTagsFromStreamCommand)
+    .sc(RemoveTagsFromStream)
     .build() {
 }
 
@@ -2294,16 +1763,11 @@ class SplitShardCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "SplitShard", {})
     .n("KinesisClient", "SplitShardCommand")
-    .f(void 0, void 0)
-    .ser(se_SplitShardCommand)
-    .de(de_SplitShardCommand)
+    .sc(SplitShard)
     .build() {
 }
 
@@ -2315,16 +1779,11 @@ class StartStreamEncryptionCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "StartStreamEncryption", {})
     .n("KinesisClient", "StartStreamEncryptionCommand")
-    .f(void 0, void 0)
-    .ser(se_StartStreamEncryptionCommand)
-    .de(de_StartStreamEncryptionCommand)
+    .sc(StartStreamEncryption)
     .build() {
 }
 
@@ -2336,16 +1795,11 @@ class StopStreamEncryptionCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "StopStreamEncryption", {})
     .n("KinesisClient", "StopStreamEncryptionCommand")
-    .f(void 0, void 0)
-    .ser(se_StopStreamEncryptionCommand)
-    .de(de_StopStreamEncryptionCommand)
+    .sc(StopStreamEncryption)
     .build() {
 }
 
@@ -2357,10 +1811,7 @@ class SubscribeToShardCommand extends smithyClient.Command
     ConsumerARN: { type: "contextParams", name: "ConsumerARN" },
 })
     .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("Kinesis_20131202", "SubscribeToShard", {
     eventStream: {
@@ -2368,9 +1819,7 @@ class SubscribeToShardCommand extends smithyClient.Command
     },
 })
     .n("KinesisClient", "SubscribeToShardCommand")
-    .f(void 0, SubscribeToShardOutputFilterSensitiveLog)
-    .ser(se_SubscribeToShardCommand)
-    .de(de_SubscribeToShardCommand)
+    .sc(SubscribeToShard)
     .build() {
 }
 
@@ -2382,16 +1831,11 @@ class TagResourceCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "TagResource", {})
     .n("KinesisClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2403,16 +1847,11 @@ class UntagResourceCommand extends smithyClient.Command
     ResourceARN: { type: "contextParams", name: "ResourceARN" },
 })
     .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("Kinesis_20131202", "UntagResource", {})
     .n("KinesisClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2420,16 +1859,11 @@ class UpdateAccountSettingsCommand 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("Kinesis_20131202", "UpdateAccountSettings", {})
     .n("KinesisClient", "UpdateAccountSettingsCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateAccountSettingsCommand)
-    .de(de_UpdateAccountSettingsCommand)
+    .sc(UpdateAccountSettings)
     .build() {
 }
 
@@ -2441,16 +1875,11 @@ class UpdateMaxRecordSizeCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "UpdateMaxRecordSize", {})
     .n("KinesisClient", "UpdateMaxRecordSizeCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateMaxRecordSizeCommand)
-    .de(de_UpdateMaxRecordSizeCommand)
+    .sc(UpdateMaxRecordSize)
     .build() {
 }
 
@@ -2462,16 +1891,11 @@ class UpdateShardCountCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "UpdateShardCount", {})
     .n("KinesisClient", "UpdateShardCountCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateShardCountCommand)
-    .de(de_UpdateShardCountCommand)
+    .sc(UpdateShardCount)
     .build() {
 }
 
@@ -2483,16 +1907,11 @@ class UpdateStreamModeCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "UpdateStreamMode", {})
     .n("KinesisClient", "UpdateStreamModeCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateStreamModeCommand)
-    .de(de_UpdateStreamModeCommand)
+    .sc(UpdateStreamMode)
     .build() {
 }
 
@@ -2504,16 +1923,11 @@ class UpdateStreamWarmThroughputCommand extends smithyClient.Command
     StreamARN: { type: "contextParams", name: "StreamARN" },
 })
     .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("Kinesis_20131202", "UpdateStreamWarmThroughput", {})
     .n("KinesisClient", "UpdateStreamWarmThroughputCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateStreamWarmThroughputCommand)
-    .de(de_UpdateStreamWarmThroughputCommand)
+    .sc(UpdateStreamWarmThroughput)
     .build() {
 }
 
@@ -2628,7 +2042,7 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AddTagsToStreamCommand = AddTagsToStreamCommand;
 exports.ConsumerStatus = ConsumerStatus;
 exports.CreateStreamCommand = CreateStreamCommand;
@@ -2644,24 +2058,24 @@ exports.DescribeStreamSummaryCommand = DescribeStreamSummaryCommand;
 exports.DisableEnhancedMonitoringCommand = DisableEnhancedMonitoringCommand;
 exports.EnableEnhancedMonitoringCommand = EnableEnhancedMonitoringCommand;
 exports.EncryptionType = EncryptionType;
-exports.ExpiredIteratorException = ExpiredIteratorException;
-exports.ExpiredNextTokenException = ExpiredNextTokenException;
+exports.ExpiredIteratorException = ExpiredIteratorException$1;
+exports.ExpiredNextTokenException = ExpiredNextTokenException$1;
 exports.GetRecordsCommand = GetRecordsCommand;
 exports.GetResourcePolicyCommand = GetResourcePolicyCommand;
 exports.GetShardIteratorCommand = GetShardIteratorCommand;
 exports.IncreaseStreamRetentionPeriodCommand = IncreaseStreamRetentionPeriodCommand;
-exports.InternalFailureException = InternalFailureException;
-exports.InvalidArgumentException = InvalidArgumentException;
-exports.KMSAccessDeniedException = KMSAccessDeniedException;
-exports.KMSDisabledException = KMSDisabledException;
-exports.KMSInvalidStateException = KMSInvalidStateException;
-exports.KMSNotFoundException = KMSNotFoundException;
-exports.KMSOptInRequired = KMSOptInRequired;
-exports.KMSThrottlingException = KMSThrottlingException;
+exports.InternalFailureException = InternalFailureException$1;
+exports.InvalidArgumentException = InvalidArgumentException$1;
+exports.KMSAccessDeniedException = KMSAccessDeniedException$1;
+exports.KMSDisabledException = KMSDisabledException$1;
+exports.KMSInvalidStateException = KMSInvalidStateException$1;
+exports.KMSNotFoundException = KMSNotFoundException$1;
+exports.KMSOptInRequired = KMSOptInRequired$1;
+exports.KMSThrottlingException = KMSThrottlingException$1;
 exports.Kinesis = Kinesis;
 exports.KinesisClient = KinesisClient;
-exports.KinesisServiceException = KinesisServiceException;
-exports.LimitExceededException = LimitExceededException;
+exports.KinesisServiceException = KinesisServiceException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListShardsCommand = ListShardsCommand;
 exports.ListStreamConsumersCommand = ListStreamConsumersCommand;
 exports.ListStreamsCommand = ListStreamsCommand;
@@ -2671,14 +2085,14 @@ exports.MergeShardsCommand = MergeShardsCommand;
 exports.MetricsName = MetricsName;
 exports.MinimumThroughputBillingCommitmentInputStatus = MinimumThroughputBillingCommitmentInputStatus;
 exports.MinimumThroughputBillingCommitmentOutputStatus = MinimumThroughputBillingCommitmentOutputStatus;
-exports.ProvisionedThroughputExceededException = ProvisionedThroughputExceededException;
+exports.ProvisionedThroughputExceededException = ProvisionedThroughputExceededException$1;
 exports.PutRecordCommand = PutRecordCommand;
 exports.PutRecordsCommand = PutRecordsCommand;
 exports.PutResourcePolicyCommand = PutResourcePolicyCommand;
 exports.RegisterStreamConsumerCommand = RegisterStreamConsumerCommand;
 exports.RemoveTagsFromStreamCommand = RemoveTagsFromStreamCommand;
-exports.ResourceInUseException = ResourceInUseException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceInUseException = ResourceInUseException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ScalingType = ScalingType;
 exports.ShardFilterType = ShardFilterType;
 exports.ShardIteratorType = ShardIteratorType;
@@ -2688,8 +2102,6 @@ exports.StopStreamEncryptionCommand = StopStreamEncryptionCommand;
 exports.StreamMode = StreamMode;
 exports.StreamStatus = StreamStatus;
 exports.SubscribeToShardCommand = SubscribeToShardCommand;
-exports.SubscribeToShardEventStreamFilterSensitiveLog = SubscribeToShardEventStreamFilterSensitiveLog;
-exports.SubscribeToShardOutputFilterSensitiveLog = SubscribeToShardOutputFilterSensitiveLog;
 exports.TagResourceCommand = TagResourceCommand;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateAccountSettingsCommand = UpdateAccountSettingsCommand;
@@ -2697,7 +2109,7 @@ exports.UpdateMaxRecordSizeCommand = UpdateMaxRecordSizeCommand;
 exports.UpdateShardCountCommand = UpdateShardCountCommand;
 exports.UpdateStreamModeCommand = UpdateStreamModeCommand;
 exports.UpdateStreamWarmThroughputCommand = UpdateStreamWarmThroughputCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListStreamConsumers = paginateListStreamConsumers;
 exports.paginateListStreams = paginateListStreams;
 exports.waitForStreamExists = waitForStreamExists;