@aws-sdk/client-firehose 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class FirehoseClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class FirehoseClient extends smithyClient.Client {
     }
 }
 
-class FirehoseServiceException extends smithyClient.ServiceException {
+let FirehoseServiceException$1 = class FirehoseServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, FirehoseServiceException.prototype);
     }
-}
+};
 
 const ProcessorParameterName = {
     BUFFER_INTERVAL_IN_SECONDS: "BufferIntervalInSeconds",
@@ -171,7 +171,7 @@ const Connectivity = {
     PRIVATE: "PRIVATE",
     PUBLIC: "PUBLIC",
 };
-class ConcurrentModificationException extends FirehoseServiceException {
+let ConcurrentModificationException$1 = class ConcurrentModificationException extends FirehoseServiceException$1 {
     name = "ConcurrentModificationException";
     $fault = "client";
     constructor(opts) {
@@ -182,7 +182,7 @@ class ConcurrentModificationException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
     }
-}
+};
 const ContentEncoding = {
     GZIP: "GZIP",
     NONE: "NONE",
@@ -267,7 +267,7 @@ const SplunkS3BackupMode = {
     AllEvents: "AllEvents",
     FailedEventsOnly: "FailedEventsOnly",
 };
-class InvalidArgumentException extends FirehoseServiceException {
+let InvalidArgumentException$1 = class InvalidArgumentException extends FirehoseServiceException$1 {
     name = "InvalidArgumentException";
     $fault = "client";
     constructor(opts) {
@@ -278,8 +278,8 @@ class InvalidArgumentException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, InvalidArgumentException.prototype);
     }
-}
-class InvalidKMSResourceException extends FirehoseServiceException {
+};
+let InvalidKMSResourceException$1 = class InvalidKMSResourceException extends FirehoseServiceException$1 {
     name = "InvalidKMSResourceException";
     $fault = "client";
     code;
@@ -292,8 +292,8 @@ class InvalidKMSResourceException extends FirehoseServiceException {
         Object.setPrototypeOf(this, InvalidKMSResourceException.prototype);
         this.code = opts.code;
     }
-}
-class LimitExceededException extends FirehoseServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends FirehoseServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -304,8 +304,8 @@ class LimitExceededException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-class ResourceInUseException extends FirehoseServiceException {
+};
+let ResourceInUseException$1 = class ResourceInUseException extends FirehoseServiceException$1 {
     name = "ResourceInUseException";
     $fault = "client";
     constructor(opts) {
@@ -316,7 +316,7 @@ class ResourceInUseException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
     }
-}
+};
 const DeliveryStreamFailureType = {
     CREATE_ENI_FAILED: "CREATE_ENI_FAILED",
     CREATE_KMS_GRANT_FAILED: "CREATE_KMS_GRANT_FAILED",
@@ -345,7 +345,7 @@ const SnapshotStatus = {
     IN_PROGRESS: "IN_PROGRESS",
     SUSPENDED: "SUSPENDED",
 };
-class ResourceNotFoundException extends FirehoseServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends FirehoseServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -356,7 +356,7 @@ class ResourceNotFoundException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
+};
 const DeliveryStreamEncryptionStatus = {
     DISABLED: "DISABLED",
     DISABLING: "DISABLING",
@@ -372,7 +372,7 @@ const DeliveryStreamStatus = {
     DELETING: "DELETING",
     DELETING_FAILED: "DELETING_FAILED",
 };
-class InvalidSourceException extends FirehoseServiceException {
+let InvalidSourceException$1 = class InvalidSourceException extends FirehoseServiceException$1 {
     name = "InvalidSourceException";
     $fault = "client";
     code;
@@ -385,8 +385,8 @@ class InvalidSourceException extends FirehoseServiceException {
         Object.setPrototypeOf(this, InvalidSourceException.prototype);
         this.code = opts.code;
     }
-}
-class ServiceUnavailableException extends FirehoseServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends FirehoseServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     constructor(opts) {
@@ -397,850 +397,1618 @@ class ServiceUnavailableException extends FirehoseServiceException {
         });
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-}
-const HttpEndpointConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Url && { Url: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AccessKey && { AccessKey: smithyClient.SENSITIVE_STRING }),
-});
-const HttpEndpointCommonAttributeFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AttributeName && { AttributeName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AttributeValue && { AttributeValue: smithyClient.SENSITIVE_STRING }),
-});
-const HttpEndpointRequestConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.CommonAttributes && {
-        CommonAttributes: obj.CommonAttributes.map((item) => HttpEndpointCommonAttributeFilterSensitiveLog(item)),
-    }),
-});
-const HttpEndpointDestinationConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EndpointConfiguration && {
-        EndpointConfiguration: HttpEndpointConfigurationFilterSensitiveLog(obj.EndpointConfiguration),
-    }),
-    ...(obj.RequestConfiguration && {
-        RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration),
-    }),
-});
-const RedshiftDestinationConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Username && { Username: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Password && { Password: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeRoleConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.SnowflakeRole && { SnowflakeRole: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeVpcConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PrivateLinkVpceId && { PrivateLinkVpceId: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeDestinationConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AccountUrl && { AccountUrl: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PrivateKey && { PrivateKey: smithyClient.SENSITIVE_STRING }),
-    ...(obj.KeyPassphrase && { KeyPassphrase: smithyClient.SENSITIVE_STRING }),
-    ...(obj.User && { User: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Database && { Database: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Schema && { Schema: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Table && { Table: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SnowflakeRoleConfiguration && {
-        SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration),
-    }),
-    ...(obj.MetaDataColumnName && { MetaDataColumnName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ContentColumnName && { ContentColumnName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SnowflakeVpcConfiguration && {
-        SnowflakeVpcConfiguration: SnowflakeVpcConfigurationFilterSensitiveLog(obj.SnowflakeVpcConfiguration),
-    }),
-});
-const CreateDeliveryStreamInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RedshiftDestinationConfiguration && {
-        RedshiftDestinationConfiguration: RedshiftDestinationConfigurationFilterSensitiveLog(obj.RedshiftDestinationConfiguration),
-    }),
-    ...(obj.HttpEndpointDestinationConfiguration && {
-        HttpEndpointDestinationConfiguration: HttpEndpointDestinationConfigurationFilterSensitiveLog(obj.HttpEndpointDestinationConfiguration),
-    }),
-    ...(obj.SnowflakeDestinationConfiguration && {
-        SnowflakeDestinationConfiguration: SnowflakeDestinationConfigurationFilterSensitiveLog(obj.SnowflakeDestinationConfiguration),
-    }),
-});
-const HttpEndpointDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Url && { Url: smithyClient.SENSITIVE_STRING }),
-});
-const HttpEndpointDestinationDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EndpointConfiguration && {
-        EndpointConfiguration: HttpEndpointDescriptionFilterSensitiveLog(obj.EndpointConfiguration),
-    }),
-    ...(obj.RequestConfiguration && {
-        RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration),
-    }),
-});
-const RedshiftDestinationDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Username && { Username: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeDestinationDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AccountUrl && { AccountUrl: smithyClient.SENSITIVE_STRING }),
-    ...(obj.User && { User: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Database && { Database: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Schema && { Schema: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Table && { Table: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SnowflakeRoleConfiguration && {
-        SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration),
-    }),
-    ...(obj.MetaDataColumnName && { MetaDataColumnName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ContentColumnName && { ContentColumnName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SnowflakeVpcConfiguration && {
-        SnowflakeVpcConfiguration: SnowflakeVpcConfigurationFilterSensitiveLog(obj.SnowflakeVpcConfiguration),
-    }),
-});
-const DestinationDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RedshiftDestinationDescription && {
-        RedshiftDestinationDescription: RedshiftDestinationDescriptionFilterSensitiveLog(obj.RedshiftDestinationDescription),
-    }),
-    ...(obj.HttpEndpointDestinationDescription && {
-        HttpEndpointDestinationDescription: HttpEndpointDestinationDescriptionFilterSensitiveLog(obj.HttpEndpointDestinationDescription),
-    }),
-    ...(obj.SnowflakeDestinationDescription && {
-        SnowflakeDestinationDescription: SnowflakeDestinationDescriptionFilterSensitiveLog(obj.SnowflakeDestinationDescription),
-    }),
-});
-const DeliveryStreamDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Destinations && {
-        Destinations: obj.Destinations.map((item) => DestinationDescriptionFilterSensitiveLog(item)),
-    }),
-});
-const DescribeDeliveryStreamOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const HttpEndpointDestinationUpdateFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EndpointConfiguration && {
-        EndpointConfiguration: HttpEndpointConfigurationFilterSensitiveLog(obj.EndpointConfiguration),
-    }),
-    ...(obj.RequestConfiguration && {
-        RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration),
-    }),
-});
-const RedshiftDestinationUpdateFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Username && { Username: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Password && { Password: smithyClient.SENSITIVE_STRING }),
-});
-const SnowflakeDestinationUpdateFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AccountUrl && { AccountUrl: smithyClient.SENSITIVE_STRING }),
-    ...(obj.PrivateKey && { PrivateKey: smithyClient.SENSITIVE_STRING }),
-    ...(obj.KeyPassphrase && { KeyPassphrase: smithyClient.SENSITIVE_STRING }),
-    ...(obj.User && { User: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Database && { Database: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Schema && { Schema: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Table && { Table: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SnowflakeRoleConfiguration && {
-        SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration),
-    }),
-    ...(obj.MetaDataColumnName && { MetaDataColumnName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ContentColumnName && { ContentColumnName: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateDestinationInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RedshiftDestinationUpdate && {
-        RedshiftDestinationUpdate: RedshiftDestinationUpdateFilterSensitiveLog(obj.RedshiftDestinationUpdate),
-    }),
-    ...(obj.HttpEndpointDestinationUpdate && {
-        HttpEndpointDestinationUpdate: HttpEndpointDestinationUpdateFilterSensitiveLog(obj.HttpEndpointDestinationUpdate),
-    }),
-    ...(obj.SnowflakeDestinationUpdate && {
-        SnowflakeDestinationUpdate: SnowflakeDestinationUpdateFilterSensitiveLog(obj.SnowflakeDestinationUpdate),
-    }),
-});
-
-const se_CreateDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateDeliveryStream");
-    let body;
-    body = JSON.stringify(se_CreateDeliveryStreamInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteDeliveryStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeDeliveryStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListDeliveryStreamsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListDeliveryStreams");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForDeliveryStream");
-    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_PutRecordBatchCommand = async (input, context) => {
-    const headers = sharedHeaders("PutRecordBatch");
-    let body;
-    body = JSON.stringify(se_PutRecordBatchInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartDeliveryStreamEncryptionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartDeliveryStreamEncryption");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StopDeliveryStreamEncryptionCommand = async (input, context) => {
-    const headers = sharedHeaders("StopDeliveryStreamEncryption");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("TagDeliveryStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagDeliveryStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagDeliveryStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateDestinationCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateDestination");
-    let body;
-    body = JSON.stringify(se_UpdateDestinationInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CreateDeliveryStreamCommand = 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_DeleteDeliveryStreamCommand = 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_DescribeDeliveryStreamCommand = 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_DescribeDeliveryStreamOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListDeliveryStreamsCommand = 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_ListTagsForDeliveryStreamCommand = 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_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_PutRecordBatchCommand = 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_StartDeliveryStreamEncryptionCommand = 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_StopDeliveryStreamEncryptionCommand = 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_TagDeliveryStreamCommand = 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_UntagDeliveryStreamCommand = 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_UpdateDestinationCommand = 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 "InvalidArgumentException":
-        case "com.amazonaws.firehose#InvalidArgumentException":
-            throw await de_InvalidArgumentExceptionRes(parsedOutput);
-        case "InvalidKMSResourceException":
-        case "com.amazonaws.firehose#InvalidKMSResourceException":
-            throw await de_InvalidKMSResourceExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.firehose#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ResourceInUseException":
-        case "com.amazonaws.firehose#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.firehose#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "InvalidSourceException":
-        case "com.amazonaws.firehose#InvalidSourceException":
-            throw await de_InvalidSourceExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.firehose#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.firehose#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConcurrentModificationException({
-        $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_InvalidKMSResourceExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidKMSResourceException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidSourceExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidSourceException({
-        $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_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_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServiceUnavailableException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CreateDeliveryStreamInput = (input, context) => {
-    return smithyClient.take(input, {
-        AmazonOpenSearchServerlessDestinationConfiguration: smithyClient._json,
-        AmazonopensearchserviceDestinationConfiguration: smithyClient._json,
-        DatabaseSourceConfiguration: smithyClient._json,
-        DeliveryStreamEncryptionConfigurationInput: smithyClient._json,
-        DeliveryStreamName: [],
-        DeliveryStreamType: [],
-        DirectPutSourceConfiguration: smithyClient._json,
-        ElasticsearchDestinationConfiguration: smithyClient._json,
-        ExtendedS3DestinationConfiguration: (_) => se_ExtendedS3DestinationConfiguration(_),
-        HttpEndpointDestinationConfiguration: smithyClient._json,
-        IcebergDestinationConfiguration: smithyClient._json,
-        KinesisStreamSourceConfiguration: smithyClient._json,
-        MSKSourceConfiguration: (_) => se_MSKSourceConfiguration(_),
-        RedshiftDestinationConfiguration: smithyClient._json,
-        S3DestinationConfiguration: smithyClient._json,
-        SnowflakeDestinationConfiguration: smithyClient._json,
-        SplunkDestinationConfiguration: smithyClient._json,
-        Tags: smithyClient._json,
-    });
-};
-const se_DataFormatConversionConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        Enabled: [],
-        InputFormatConfiguration: smithyClient._json,
-        OutputFormatConfiguration: (_) => se_OutputFormatConfiguration(_),
-        SchemaConfiguration: smithyClient._json,
-    });
-};
-const se_ExtendedS3DestinationConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        BucketARN: [],
-        BufferingHints: smithyClient._json,
-        CloudWatchLoggingOptions: smithyClient._json,
-        CompressionFormat: [],
-        CustomTimeZone: [],
-        DataFormatConversionConfiguration: (_) => se_DataFormatConversionConfiguration(_),
-        DynamicPartitioningConfiguration: smithyClient._json,
-        EncryptionConfiguration: smithyClient._json,
-        ErrorOutputPrefix: [],
-        FileExtension: [],
-        Prefix: [],
-        ProcessingConfiguration: smithyClient._json,
-        RoleARN: [],
-        S3BackupConfiguration: smithyClient._json,
-        S3BackupMode: [],
-    });
-};
-const se_ExtendedS3DestinationUpdate = (input, context) => {
-    return smithyClient.take(input, {
-        BucketARN: [],
-        BufferingHints: smithyClient._json,
-        CloudWatchLoggingOptions: smithyClient._json,
-        CompressionFormat: [],
-        CustomTimeZone: [],
-        DataFormatConversionConfiguration: (_) => se_DataFormatConversionConfiguration(_),
-        DynamicPartitioningConfiguration: smithyClient._json,
-        EncryptionConfiguration: smithyClient._json,
-        ErrorOutputPrefix: [],
-        FileExtension: [],
-        Prefix: [],
-        ProcessingConfiguration: smithyClient._json,
-        RoleARN: [],
-        S3BackupMode: [],
-        S3BackupUpdate: smithyClient._json,
-    });
-};
-const se_MSKSourceConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        AuthenticationConfiguration: smithyClient._json,
-        MSKClusterARN: [],
-        ReadFromTimestamp: (_) => _.getTime() / 1_000,
-        TopicName: [],
-    });
-};
-const se_OrcSerDe = (input, context) => {
-    return smithyClient.take(input, {
-        BlockSizeBytes: [],
-        BloomFilterColumns: smithyClient._json,
-        BloomFilterFalsePositiveProbability: smithyClient.serializeFloat,
-        Compression: [],
-        DictionaryKeyThreshold: smithyClient.serializeFloat,
-        EnablePadding: [],
-        FormatVersion: [],
-        PaddingTolerance: smithyClient.serializeFloat,
-        RowIndexStride: [],
-        StripeSizeBytes: [],
-    });
-};
-const se_OutputFormatConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        Serializer: (_) => se_Serializer(_),
-    });
-};
-const se_PutRecordBatchInput = (input, context) => {
-    return smithyClient.take(input, {
-        DeliveryStreamName: [],
-        Records: (_) => se_PutRecordBatchRequestEntryList(_, context),
-    });
-};
-const se_PutRecordBatchRequestEntryList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se__Record(entry, context);
-    });
-};
-const se_PutRecordInput = (input, context) => {
-    return smithyClient.take(input, {
-        DeliveryStreamName: [],
-        Record: (_) => se__Record(_, context),
-    });
-};
-const se__Record = (input, context) => {
-    return smithyClient.take(input, {
-        Data: context.base64Encoder,
-    });
 };
-const se_Serializer = (input, context) => {
-    return smithyClient.take(input, {
-        OrcSerDe: (_) => se_OrcSerDe(_),
-        ParquetSerDe: smithyClient._json,
-    });
-};
-const se_UpdateDestinationInput = (input, context) => {
-    return smithyClient.take(input, {
-        AmazonOpenSearchServerlessDestinationUpdate: smithyClient._json,
-        AmazonopensearchserviceDestinationUpdate: smithyClient._json,
-        CurrentDeliveryStreamVersionId: [],
-        DeliveryStreamName: [],
-        DestinationId: [],
-        ElasticsearchDestinationUpdate: smithyClient._json,
-        ExtendedS3DestinationUpdate: (_) => se_ExtendedS3DestinationUpdate(_),
-        HttpEndpointDestinationUpdate: smithyClient._json,
-        IcebergDestinationUpdate: smithyClient._json,
-        RedshiftDestinationUpdate: smithyClient._json,
-        S3DestinationUpdate: smithyClient._json,
-        SnowflakeDestinationUpdate: smithyClient._json,
-        SplunkDestinationUpdate: smithyClient._json,
-    });
-};
-const de_DatabaseSnapshotInfo = (output, context) => {
-    return smithyClient.take(output, {
-        FailureDescription: smithyClient._json,
-        Id: smithyClient.expectString,
-        RequestTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RequestedBy: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Table: smithyClient.expectString,
-    });
-};
-const de_DatabaseSnapshotInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DatabaseSnapshotInfo(entry);
-    });
-    return retVal;
-};
-const de_DatabaseSourceDescription = (output, context) => {
-    return smithyClient.take(output, {
-        Columns: smithyClient._json,
-        DatabaseSourceAuthenticationConfiguration: smithyClient._json,
-        DatabaseSourceVPCConfiguration: smithyClient._json,
-        Databases: smithyClient._json,
-        Endpoint: smithyClient.expectString,
-        Port: smithyClient.expectInt32,
-        SSLMode: smithyClient.expectString,
-        SnapshotInfo: (_) => de_DatabaseSnapshotInfoList(_),
-        SnapshotWatermarkTable: smithyClient.expectString,
-        SurrogateKeys: smithyClient._json,
-        Tables: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_DataFormatConversionConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        Enabled: smithyClient.expectBoolean,
-        InputFormatConfiguration: smithyClient._json,
-        OutputFormatConfiguration: (_) => de_OutputFormatConfiguration(_),
-        SchemaConfiguration: smithyClient._json,
-    });
-};
-const de_DeliveryStreamDescription = (output, context) => {
-    return smithyClient.take(output, {
-        CreateTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DeliveryStreamARN: smithyClient.expectString,
-        DeliveryStreamEncryptionConfiguration: smithyClient._json,
-        DeliveryStreamName: smithyClient.expectString,
-        DeliveryStreamStatus: smithyClient.expectString,
-        DeliveryStreamType: smithyClient.expectString,
-        Destinations: (_) => de_DestinationDescriptionList(_),
-        FailureDescription: smithyClient._json,
-        HasMoreDestinations: smithyClient.expectBoolean,
-        LastUpdateTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Source: (_) => de_SourceDescription(_),
-        VersionId: smithyClient.expectString,
-    });
-};
-const de_DescribeDeliveryStreamOutput = (output, context) => {
-    return smithyClient.take(output, {
-        DeliveryStreamDescription: (_) => de_DeliveryStreamDescription(_),
-    });
-};
-const de_DestinationDescription = (output, context) => {
-    return smithyClient.take(output, {
-        AmazonOpenSearchServerlessDestinationDescription: smithyClient._json,
-        AmazonopensearchserviceDestinationDescription: smithyClient._json,
-        DestinationId: smithyClient.expectString,
-        ElasticsearchDestinationDescription: smithyClient._json,
-        ExtendedS3DestinationDescription: (_) => de_ExtendedS3DestinationDescription(_),
-        HttpEndpointDestinationDescription: smithyClient._json,
-        IcebergDestinationDescription: smithyClient._json,
-        RedshiftDestinationDescription: smithyClient._json,
-        S3DestinationDescription: smithyClient._json,
-        SnowflakeDestinationDescription: smithyClient._json,
-        SplunkDestinationDescription: smithyClient._json,
-    });
-};
-const de_DestinationDescriptionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DestinationDescription(entry);
-    });
-    return retVal;
-};
-const de_ExtendedS3DestinationDescription = (output, context) => {
-    return smithyClient.take(output, {
-        BucketARN: smithyClient.expectString,
-        BufferingHints: smithyClient._json,
-        CloudWatchLoggingOptions: smithyClient._json,
-        CompressionFormat: smithyClient.expectString,
-        CustomTimeZone: smithyClient.expectString,
-        DataFormatConversionConfiguration: (_) => de_DataFormatConversionConfiguration(_),
-        DynamicPartitioningConfiguration: smithyClient._json,
-        EncryptionConfiguration: smithyClient._json,
-        ErrorOutputPrefix: smithyClient.expectString,
-        FileExtension: smithyClient.expectString,
-        Prefix: smithyClient.expectString,
-        ProcessingConfiguration: smithyClient._json,
-        RoleARN: smithyClient.expectString,
-        S3BackupDescription: smithyClient._json,
-        S3BackupMode: smithyClient.expectString,
-    });
-};
-const de_KinesisStreamSourceDescription = (output, context) => {
-    return smithyClient.take(output, {
-        DeliveryStartTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        KinesisStreamARN: smithyClient.expectString,
-        RoleARN: smithyClient.expectString,
-    });
-};
-const de_MSKSourceDescription = (output, context) => {
-    return smithyClient.take(output, {
-        AuthenticationConfiguration: smithyClient._json,
-        DeliveryStartTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MSKClusterARN: smithyClient.expectString,
-        ReadFromTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        TopicName: smithyClient.expectString,
-    });
-};
-const de_OrcSerDe = (output, context) => {
-    return smithyClient.take(output, {
-        BlockSizeBytes: smithyClient.expectInt32,
-        BloomFilterColumns: smithyClient._json,
-        BloomFilterFalsePositiveProbability: smithyClient.limitedParseDouble,
-        Compression: smithyClient.expectString,
-        DictionaryKeyThreshold: smithyClient.limitedParseDouble,
-        EnablePadding: smithyClient.expectBoolean,
-        FormatVersion: smithyClient.expectString,
-        PaddingTolerance: smithyClient.limitedParseDouble,
-        RowIndexStride: smithyClient.expectInt32,
-        StripeSizeBytes: smithyClient.expectInt32,
-    });
-};
-const de_OutputFormatConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        Serializer: (_) => de_Serializer(_),
-    });
-};
-const de_Serializer = (output, context) => {
-    return smithyClient.take(output, {
-        OrcSerDe: (_) => de_OrcSerDe(_),
-        ParquetSerDe: smithyClient._json,
-    });
-};
-const de_SourceDescription = (output, context) => {
-    return smithyClient.take(output, {
-        DatabaseSourceDescription: (_) => de_DatabaseSourceDescription(_),
-        DirectPutSourceDescription: smithyClient._json,
-        KinesisStreamSourceDescription: (_) => de_KinesisStreamSourceDescription(_),
-        MSKSourceDescription: (_) => de_MSKSourceDescription(_),
-    });
-};
-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(FirehoseServiceException);
-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": `Firehose_20150804.${operation}`,
-    };
-}
+
+const _ABH = "AmazonopensearchserviceBufferingHints";
+const _AC = "AuthenticationConfiguration";
+const _ADC = "AmazonopensearchserviceDestinationConfiguration";
+const _ADD = "AmazonopensearchserviceDestinationDescription";
+const _ADU = "AmazonopensearchserviceDestinationUpdate";
+const _AFD = "AllowForceDelete";
+const _AK = "AccessKey";
+const _AN = "AttributeName";
+const _AO = "AppendOnly";
+const _AOSSBH = "AmazonOpenSearchServerlessBufferingHints";
+const _AOSSDC = "AmazonOpenSearchServerlessDestinationConfiguration";
+const _AOSSDD = "AmazonOpenSearchServerlessDestinationDescription";
+const _AOSSDU = "AmazonOpenSearchServerlessDestinationUpdate";
+const _AOSSRO = "AmazonOpenSearchServerlessRetryOptions";
+const _ARO = "AmazonopensearchserviceRetryOptions";
+const _AU = "AccountUrl";
+const _AV = "AttributeValue";
+const _AWSKMSKARN = "AWSKMSKeyARN";
+const _BARN = "BucketARN";
+const _BFC = "BloomFilterColumns";
+const _BFFPP = "BloomFilterFalsePositiveProbability";
+const _BH = "BufferingHints";
+const _BSB = "BlockSizeBytes";
+const _C = "Connectivity";
+const _CA = "CommonAttributes";
+const _CARN = "CatalogARN";
+const _CC = "CatalogConfiguration";
+const _CCN = "ContentColumnName";
+const _CCo = "CopyCommand";
+const _CDIJKTU = "ConvertDotsInJsonKeysToUnderscores";
+const _CDS = "CreateDeliveryStream";
+const _CDSI = "CreateDeliveryStreamInput";
+const _CDSO = "CreateDeliveryStreamOutput";
+const _CDSVI = "CurrentDeliveryStreamVersionId";
+const _CE = "CollectionEndpoint";
+const _CEl = "ClusterEndpoint";
+const _CEo = "ContentEncoding";
+const _CF = "CompressionFormat";
+const _CI = "CaseInsensitive";
+const _CIa = "CatalogId";
+const _CJDBCURL = "ClusterJDBCURL";
+const _CME = "ConcurrentModificationException";
+const _CO = "CopyOptions";
+const _CT = "CreateTimestamp";
+const _CTJKM = "ColumnToJsonKeyMappings";
+const _CTZ = "CustomTimeZone";
+const _CWLO = "CloudWatchLoggingOptions";
+const _Co = "Columns";
+const _Com = "Compression";
+const _D = "Databases";
+const _DARN = "DomainARN";
+const _DCL = "DatabaseColumnList";
+const _DD = "DestinationDescription";
+const _DDIF = "DefaultDocumentIdFormat";
+const _DDL = "DestinationDescriptionList";
+const _DDN = "DestinationDatabaseName";
+const _DDS = "DeleteDeliveryStream";
+const _DDSI = "DeleteDeliveryStreamInput";
+const _DDSIe = "DescribeDeliveryStreamInput";
+const _DDSO = "DeleteDeliveryStreamOutput";
+const _DDSOe = "DescribeDeliveryStreamOutput";
+const _DDSe = "DescribeDeliveryStream";
+const _DFCC = "DataFormatConversionConfiguration";
+const _DI = "DestinationId";
+const _DIO = "DocumentIdOptions";
+const _DIS = "DurationInSeconds";
+const _DKT = "DictionaryKeyThreshold";
+const _DL = "DatabaseList";
+const _DLO = "DataLoadingOption";
+const _DN = "DatabaseName";
+const _DPC = "DynamicPartitioningConfiguration";
+const _DPSC = "DirectPutSourceConfiguration";
+const _DPSD = "DirectPutSourceDescription";
+const _DSAC = "DatabaseSourceAuthenticationConfiguration";
+const _DSARN = "DeliveryStreamARN";
+const _DSC = "DatabaseSourceConfiguration";
+const _DSD = "DatabaseSourceDescription";
+const _DSDe = "DeliveryStreamDescription";
+const _DSEC = "DeliveryStreamEncryptionConfiguration";
+const _DSECI = "DeliveryStreamEncryptionConfigurationInput";
+const _DSI = "DatabaseSnapshotInfo";
+const _DSIL = "DatabaseSnapshotInfoList";
+const _DSN = "DeliveryStreamName";
+const _DSNe = "DeliveryStreamNames";
+const _DSS = "DeliveryStreamStatus";
+const _DST = "DeliveryStreamType";
+const _DSTe = "DeliveryStartTimestamp";
+const _DSVPCC = "DatabaseSourceVPCConfiguration";
+const _DTC = "DataTableColumns";
+const _DTCL = "DestinationTableConfigurationList";
+const _DTCe = "DestinationTableConfiguration";
+const _DTL = "DatabaseTableList";
+const _DTN = "DataTableName";
+const _DTNe = "DestinationTableName";
+const _Da = "Data";
+const _Dat = "Database";
+const _De = "Destinations";
+const _Des = "Deserializer";
+const _Det = "Details";
+const _E = "Enabled";
+const _EBH = "ElasticsearchBufferingHints";
+const _EC = "EncryptionConfiguration";
+const _ECn = "EndpointConfiguration";
+const _ECr = "ErrorCode";
+const _EDC = "ElasticsearchDestinationConfiguration";
+const _EDCn = "EnableDictionaryCompression";
+const _EDD = "ElasticsearchDestinationDescription";
+const _EDU = "ElasticsearchDestinationUpdate";
+const _EM = "ErrorMessage";
+const _EOP = "ErrorOutputPrefix";
+const _EP = "EnablePadding";
+const _ERO = "ElasticsearchRetryOptions";
+const _ESDC = "ExtendedS3DestinationConfiguration";
+const _ESDD = "ExtendedS3DestinationDescription";
+const _ESDI = "ExclusiveStartDestinationId";
+const _ESDSN = "ExclusiveStartDeliveryStreamName";
+const _ESDU = "ExtendedS3DestinationUpdate";
+const _ESTK = "ExclusiveStartTagKey";
+const _En = "Endpoint";
+const _Enc = "Encrypted";
+const _Ex = "Exclude";
+const _FD = "FailureDescription";
+const _FE = "FileExtension";
+const _FPC = "FailedPutCount";
+const _FV = "FormatVersion";
+const _HEAK = "HttpEndpointAccessKey";
+const _HEAN = "HttpEndpointAttributeName";
+const _HEAV = "HttpEndpointAttributeValue";
+const _HEBH = "HttpEndpointBufferingHints";
+const _HEC = "HttpEndpointConfiguration";
+const _HECA = "HttpEndpointCommonAttribute";
+const _HECAL = "HttpEndpointCommonAttributesList";
+const _HECATIS = "HECAcknowledgmentTimeoutInSeconds";
+const _HECE = "HECEndpoint";
+const _HECET = "HECEndpointType";
+const _HECT = "HECToken";
+const _HED = "HttpEndpointDescription";
+const _HEDC = "HttpEndpointDestinationConfiguration";
+const _HEDD = "HttpEndpointDestinationDescription";
+const _HEDU = "HttpEndpointDestinationUpdate";
+const _HERC = "HttpEndpointRequestConfiguration";
+const _HERO = "HttpEndpointRetryOptions";
+const _HEU = "HttpEndpointUrl";
+const _HJSD = "HiveJsonSerDe";
+const _HMD = "HasMoreDestinations";
+const _HMDS = "HasMoreDeliveryStreams";
+const _HMT = "HasMoreTags";
+const _I = "Include";
+const _IAE = "InvalidArgumentException";
+const _IDC = "IcebergDestinationConfiguration";
+const _IDD = "IcebergDestinationDescription";
+const _IDU = "IcebergDestinationUpdate";
+const _IFC = "InputFormatConfiguration";
+const _IIS = "IntervalInSeconds";
+const _IKMSRE = "InvalidKMSResourceException";
+const _IN = "IndexName";
+const _IRP = "IndexRotationPeriod";
+const _ISE = "InvalidSourceException";
+const _Id = "Id";
+const _Ide = "Identity";
+const _K = "Key";
+const _KARN = "KeyARN";
+const _KMSEC = "KMSEncryptionConfig";
+const _KP = "KeyPassphrase";
+const _KSARN = "KinesisStreamARN";
+const _KSSC = "KinesisStreamSourceConfiguration";
+const _KSSD = "KinesisStreamSourceDescription";
+const _KT = "KeyType";
+const _L = "Limit";
+const _LDS = "ListDeliveryStreams";
+const _LDSI = "ListDeliveryStreamsInput";
+const _LDSO = "ListDeliveryStreamsOutput";
+const _LEE = "LimitExceededException";
+const _LGN = "LogGroupName";
+const _LSN = "LogStreamName";
+const _LTFDS = "ListTagsForDeliveryStream";
+const _LTFDSI = "ListTagsForDeliveryStreamInput";
+const _LTFDSO = "ListTagsForDeliveryStreamOutput";
+const _LTFDSOTL = "ListTagsForDeliveryStreamOutputTagList";
+const _LUT = "LastUpdateTimestamp";
+const _MDCN = "MetaDataColumnName";
+const _MPB = "MaxPaddingBytes";
+const _MSKCARN = "MSKClusterARN";
+const _MSKSC = "MSKSourceConfiguration";
+const _MSKSD = "MSKSourceDescription";
+const _N = "Name";
+const _NEC = "NoEncryptionConfig";
+const _OFC = "OutputFormatConfiguration";
+const _OSD = "OrcSerDe";
+const _OXJSD = "OpenXJsonSerDe";
+const _P = "Password";
+const _PC = "ProcessingConfiguration";
+const _PF = "PartitionField";
+const _PFa = "PartitionFields";
+const _PK = "PrivateKey";
+const _PL = "ProcessorList";
+const _PLVI = "PrivateLinkVpceId";
+const _PN = "ParameterName";
+const _PP = "ProcessorParameter";
+const _PPL = "ProcessorParameterList";
+const _PR = "PutRecord";
+const _PRB = "PutRecordBatch";
+const _PRBI = "PutRecordBatchInput";
+const _PRBO = "PutRecordBatchOutput";
+const _PRBRE = "PutRecordBatchResponseEntry";
+const _PRBREL = "PutRecordBatchRequestEntryList";
+const _PRBRELu = "PutRecordBatchResponseEntryList";
+const _PRI = "PutRecordInput";
+const _PRO = "PutRecordOutput";
+const _PS = "PartitionSpec";
+const _PSB = "PageSizeBytes";
+const _PSD = "ParquetSerDe";
+const _PT = "PaddingTolerance";
+const _PV = "ParameterValue";
+const _Pa = "Parameters";
+const _Po = "Port";
+const _Pr = "Prefix";
+const _Pro = "Processors";
+const _Proc = "Processor";
+const _R = "Records";
+const _RARN = "RoleARN";
+const _RB = "RequestedBy";
+const _RC = "RequestConfiguration";
+const _RDC = "RedshiftDestinationConfiguration";
+const _RDD = "RedshiftDestinationDescription";
+const _RDU = "RedshiftDestinationUpdate";
+const _RFT = "ReadFromTimestamp";
+const _RI = "RecordId";
+const _RIS = "RowIndexStride";
+const _RIUE = "ResourceInUseException";
+const _RNFE = "ResourceNotFoundException";
+const _RO = "RetryOptions";
+const _RR = "RequestResponses";
+const _RRO = "RedshiftRetryOptions";
+const _RT = "RequestTimestamp";
+const _Re = "Record";
+const _Reg = "Region";
+const _S = "Status";
+const _SARN = "SecretARN";
+const _SAU = "SnowflakeAccountUrl";
+const _SBC = "S3BackupConfiguration";
+const _SBD = "S3BackupDescription";
+const _SBH = "SnowflakeBufferingHints";
+const _SBHp = "SplunkBufferingHints";
+const _SBM = "S3BackupMode";
+const _SBU = "S3BackupUpdate";
+const _SC = "S3Configuration";
+const _SCCN = "SnowflakeContentColumnName";
+const _SCc = "SchemaConfiguration";
+const _SD = "SnowflakeDatabase";
+const _SDC = "S3DestinationConfiguration";
+const _SDCn = "SnowflakeDestinationConfiguration";
+const _SDCp = "SplunkDestinationConfiguration";
+const _SDD = "S3DestinationDescription";
+const _SDDn = "SnowflakeDestinationDescription";
+const _SDDp = "SplunkDestinationDescription";
+const _SDSE = "StartDeliveryStreamEncryption";
+const _SDSEI = "StartDeliveryStreamEncryptionInput";
+const _SDSEIt = "StopDeliveryStreamEncryptionInput";
+const _SDSEO = "StartDeliveryStreamEncryptionOutput";
+const _SDSEOt = "StopDeliveryStreamEncryptionOutput";
+const _SDSEt = "StopDeliveryStreamEncryption";
+const _SDU = "S3DestinationUpdate";
+const _SDUn = "SnowflakeDestinationUpdate";
+const _SDUp = "SplunkDestinationUpdate";
+const _SDo = "SourceDescription";
+const _SEC = "SchemaEvolutionConfiguration";
+const _SEOP = "S3ErrorOutputPrefix";
+const _SGI = "SecurityGroupIds";
+const _SI = "SnapshotInfo";
+const _SIMB = "SizeInMBs";
+const _SIu = "SubnetIds";
+const _SK = "SurrogateKeys";
+const _SKP = "SnowflakeKeyPassphrase";
+const _SMC = "SecretsManagerConfiguration";
+const _SMDCN = "SnowflakeMetaDataColumnName";
+const _SN = "SourceName";
+const _SPK = "SnowflakePrivateKey";
+const _SPLVI = "SnowflakePrivateLinkVpceId";
+const _SR = "SnowflakeRole";
+const _SRC = "SnowflakeRoleConfiguration";
+const _SRO = "SnowflakeRetryOptions";
+const _SROp = "SplunkRetryOptions";
+const _SS = "SnowflakeSchema";
+const _SSB = "StripeSizeBytes";
+const _SSLM = "SSLMode";
+const _ST = "SnowflakeTable";
+const _SU = "SnowflakeUser";
+const _SUE = "ServiceUnavailableException";
+const _SUp = "S3Update";
+const _SVC = "SnowflakeVpcConfiguration";
+const _SWT = "SnapshotWatermarkTable";
+const _Sc = "Schema";
+const _Se = "Serializer";
+const _So = "Source";
+const _T = "Tags";
+const _TCC = "TableCreationConfiguration";
+const _TDS = "TagDeliveryStream";
+const _TDSI = "TagDeliveryStreamInput";
+const _TDSITL = "TagDeliveryStreamInputTagList";
+const _TDSO = "TagDeliveryStreamOutput";
+const _TF = "TimestampFormats";
+const _THIMB = "ThroughputHintInMBs";
+const _TK = "TagKeys";
+const _TN = "TypeName";
+const _TNa = "TableName";
+const _TNo = "TopicName";
+const _Ta = "Table";
+const _Tab = "Tables";
+const _Tag = "Tag";
+const _Ty = "Type";
+const _U = "Username";
+const _UD = "UpdateDestination";
+const _UDI = "UpdateDestinationInput";
+const _UDO = "UpdateDestinationOutput";
+const _UDS = "UntagDeliveryStream";
+const _UDSI = "UntagDeliveryStreamInput";
+const _UDSO = "UntagDeliveryStreamOutput";
+const _UK = "UniqueKeys";
+const _Ur = "Url";
+const _Us = "User";
+const _V = "Value";
+const _VC = "VpcConfiguration";
+const _VCD = "VpcConfigurationDescription";
+const _VESN = "VpcEndpointServiceName";
+const _VI = "VersionId";
+const _VIp = "VpcId";
+const _WL = "WarehouseLocation";
+const _WV = "WriterVersion";
+const _c = "client";
+const _co = "code";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.firehose";
+const n0 = "com.amazonaws.firehose";
+var HttpEndpointAccessKey = [0, n0, _HEAK, 8, 0];
+var HttpEndpointAttributeName = [0, n0, _HEAN, 8, 0];
+var HttpEndpointAttributeValue = [0, n0, _HEAV, 8, 0];
+var HttpEndpointUrl = [0, n0, _HEU, 8, 0];
+var Password = [0, n0, _P, 8, 0];
+var SnowflakeAccountUrl = [0, n0, _SAU, 8, 0];
+var SnowflakeContentColumnName = [0, n0, _SCCN, 8, 0];
+var SnowflakeDatabase = [0, n0, _SD, 8, 0];
+var SnowflakeKeyPassphrase = [0, n0, _SKP, 8, 0];
+var SnowflakeMetaDataColumnName = [0, n0, _SMDCN, 8, 0];
+var SnowflakePrivateKey = [0, n0, _SPK, 8, 0];
+var SnowflakePrivateLinkVpceId = [0, n0, _SPLVI, 8, 0];
+var SnowflakeRole = [0, n0, _SR, 8, 0];
+var SnowflakeSchema = [0, n0, _SS, 8, 0];
+var SnowflakeTable = [0, n0, _ST, 8, 0];
+var SnowflakeUser = [0, n0, _SU, 8, 0];
+var Username = [0, n0, _U, 8, 0];
+var AmazonOpenSearchServerlessBufferingHints = [3, n0, _AOSSBH, 0, [_IIS, _SIMB], [1, 1]];
+var AmazonOpenSearchServerlessDestinationConfiguration = [
+    3,
+    n0,
+    _AOSSDC,
+    0,
+    [_RARN, _CE, _IN, _BH, _RO, _SBM, _SC, _PC, _CWLO, _VC],
+    [
+        0,
+        0,
+        0,
+        () => AmazonOpenSearchServerlessBufferingHints,
+        () => AmazonOpenSearchServerlessRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfiguration,
+    ],
+];
+var AmazonOpenSearchServerlessDestinationDescription = [
+    3,
+    n0,
+    _AOSSDD,
+    0,
+    [_RARN, _CE, _IN, _BH, _RO, _SBM, _SDD, _PC, _CWLO, _VCD],
+    [
+        0,
+        0,
+        0,
+        () => AmazonOpenSearchServerlessBufferingHints,
+        () => AmazonOpenSearchServerlessRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfigurationDescription,
+    ],
+];
+var AmazonOpenSearchServerlessDestinationUpdate = [
+    3,
+    n0,
+    _AOSSDU,
+    0,
+    [_RARN, _CE, _IN, _BH, _RO, _SUp, _PC, _CWLO],
+    [
+        0,
+        0,
+        0,
+        () => AmazonOpenSearchServerlessBufferingHints,
+        () => AmazonOpenSearchServerlessRetryOptions,
+        () => S3DestinationUpdate,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+    ],
+];
+var AmazonOpenSearchServerlessRetryOptions = [3, n0, _AOSSRO, 0, [_DIS], [1]];
+var AmazonopensearchserviceBufferingHints = [3, n0, _ABH, 0, [_IIS, _SIMB], [1, 1]];
+var AmazonopensearchserviceDestinationConfiguration = [
+    3,
+    n0,
+    _ADC,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SBM, _SC, _PC, _CWLO, _VC, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => AmazonopensearchserviceBufferingHints,
+        () => AmazonopensearchserviceRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfiguration,
+        () => DocumentIdOptions,
+    ],
+];
+var AmazonopensearchserviceDestinationDescription = [
+    3,
+    n0,
+    _ADD,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SBM, _SDD, _PC, _CWLO, _VCD, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => AmazonopensearchserviceBufferingHints,
+        () => AmazonopensearchserviceRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfigurationDescription,
+        () => DocumentIdOptions,
+    ],
+];
+var AmazonopensearchserviceDestinationUpdate = [
+    3,
+    n0,
+    _ADU,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SUp, _PC, _CWLO, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => AmazonopensearchserviceBufferingHints,
+        () => AmazonopensearchserviceRetryOptions,
+        () => S3DestinationUpdate,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => DocumentIdOptions,
+    ],
+];
+var AmazonopensearchserviceRetryOptions = [3, n0, _ARO, 0, [_DIS], [1]];
+var AuthenticationConfiguration = [3, n0, _AC, 0, [_RARN, _C], [0, 0]];
+var BufferingHints = [3, n0, _BH, 0, [_SIMB, _IIS], [1, 1]];
+var CatalogConfiguration = [3, n0, _CC, 0, [_CARN, _WL], [0, 0]];
+var CloudWatchLoggingOptions = [3, n0, _CWLO, 0, [_E, _LGN, _LSN], [2, 0, 0]];
+var ConcurrentModificationException = [
+    -3,
+    n0,
+    _CME,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConcurrentModificationException, ConcurrentModificationException$1);
+var CopyCommand = [3, n0, _CCo, 0, [_DTN, _DTC, _CO], [0, 0, 0]];
+var CreateDeliveryStreamInput = [
+    3,
+    n0,
+    _CDSI,
+    0,
+    [
+        _DSN,
+        _DST,
+        _DPSC,
+        _KSSC,
+        _DSECI,
+        _SDC,
+        _ESDC,
+        _RDC,
+        _EDC,
+        _ADC,
+        _SDCp,
+        _HEDC,
+        _T,
+        _AOSSDC,
+        _MSKSC,
+        _SDCn,
+        _IDC,
+        _DSC,
+    ],
+    [
+        0,
+        0,
+        () => DirectPutSourceConfiguration,
+        () => KinesisStreamSourceConfiguration,
+        () => DeliveryStreamEncryptionConfigurationInput,
+        () => S3DestinationConfiguration,
+        () => ExtendedS3DestinationConfiguration,
+        [() => RedshiftDestinationConfiguration, 0],
+        () => ElasticsearchDestinationConfiguration,
+        () => AmazonopensearchserviceDestinationConfiguration,
+        () => SplunkDestinationConfiguration,
+        [() => HttpEndpointDestinationConfiguration, 0],
+        () => TagDeliveryStreamInputTagList,
+        () => AmazonOpenSearchServerlessDestinationConfiguration,
+        () => MSKSourceConfiguration,
+        [() => SnowflakeDestinationConfiguration, 0],
+        () => IcebergDestinationConfiguration,
+        () => DatabaseSourceConfiguration,
+    ],
+];
+var CreateDeliveryStreamOutput = [3, n0, _CDSO, 0, [_DSARN], [0]];
+var DatabaseColumnList = [3, n0, _DCL, 0, [_I, _Ex], [64 | 0, 64 | 0]];
+var DatabaseList = [3, n0, _DL, 0, [_I, _Ex], [64 | 0, 64 | 0]];
+var DatabaseSnapshotInfo = [
+    3,
+    n0,
+    _DSI,
+    0,
+    [_Id, _Ta, _RT, _RB, _S, _FD],
+    [0, 0, 4, 0, 0, () => FailureDescription],
+];
+var DatabaseSourceAuthenticationConfiguration = [
+    3,
+    n0,
+    _DSAC,
+    0,
+    [_SMC],
+    [() => SecretsManagerConfiguration],
+];
+var DatabaseSourceConfiguration = [
+    3,
+    n0,
+    _DSC,
+    0,
+    [_Ty, _En, _Po, _SSLM, _D, _Tab, _Co, _SK, _SWT, _DSAC, _DSVPCC],
+    [
+        0,
+        0,
+        1,
+        0,
+        () => DatabaseList,
+        () => DatabaseTableList,
+        () => DatabaseColumnList,
+        64 | 0,
+        0,
+        () => DatabaseSourceAuthenticationConfiguration,
+        () => DatabaseSourceVPCConfiguration,
+    ],
+];
+var DatabaseSourceDescription = [
+    3,
+    n0,
+    _DSD,
+    0,
+    [_Ty, _En, _Po, _SSLM, _D, _Tab, _Co, _SK, _SWT, _SI, _DSAC, _DSVPCC],
+    [
+        0,
+        0,
+        1,
+        0,
+        () => DatabaseList,
+        () => DatabaseTableList,
+        () => DatabaseColumnList,
+        64 | 0,
+        0,
+        () => DatabaseSnapshotInfoList,
+        () => DatabaseSourceAuthenticationConfiguration,
+        () => DatabaseSourceVPCConfiguration,
+    ],
+];
+var DatabaseSourceVPCConfiguration = [3, n0, _DSVPCC, 0, [_VESN], [0]];
+var DatabaseTableList = [3, n0, _DTL, 0, [_I, _Ex], [64 | 0, 64 | 0]];
+var DataFormatConversionConfiguration = [
+    3,
+    n0,
+    _DFCC,
+    0,
+    [_SCc, _IFC, _OFC, _E],
+    [() => SchemaConfiguration, () => InputFormatConfiguration, () => OutputFormatConfiguration, 2],
+];
+var DeleteDeliveryStreamInput = [3, n0, _DDSI, 0, [_DSN, _AFD], [0, 2]];
+var DeleteDeliveryStreamOutput = [3, n0, _DDSO, 0, [], []];
+var DeliveryStreamDescription = [
+    3,
+    n0,
+    _DSDe,
+    0,
+    [_DSN, _DSARN, _DSS, _FD, _DSEC, _DST, _VI, _CT, _LUT, _So, _De, _HMD],
+    [
+        0,
+        0,
+        0,
+        () => FailureDescription,
+        () => DeliveryStreamEncryptionConfiguration,
+        0,
+        0,
+        4,
+        4,
+        () => SourceDescription,
+        [() => DestinationDescriptionList, 0],
+        2,
+    ],
+];
+var DeliveryStreamEncryptionConfiguration = [
+    3,
+    n0,
+    _DSEC,
+    0,
+    [_KARN, _KT, _S, _FD],
+    [0, 0, 0, () => FailureDescription],
+];
+var DeliveryStreamEncryptionConfigurationInput = [3, n0, _DSECI, 0, [_KARN, _KT], [0, 0]];
+var DescribeDeliveryStreamInput = [3, n0, _DDSIe, 0, [_DSN, _L, _ESDI], [0, 1, 0]];
+var DescribeDeliveryStreamOutput = [
+    3,
+    n0,
+    _DDSOe,
+    0,
+    [_DSDe],
+    [[() => DeliveryStreamDescription, 0]],
+];
+var Deserializer = [
+    3,
+    n0,
+    _Des,
+    0,
+    [_OXJSD, _HJSD],
+    [() => OpenXJsonSerDe, () => HiveJsonSerDe],
+];
+var DestinationDescription = [
+    3,
+    n0,
+    _DD,
+    0,
+    [_DI, _SDD, _ESDD, _RDD, _EDD, _ADD, _SDDp, _HEDD, _SDDn, _AOSSDD, _IDD],
+    [
+        0,
+        () => S3DestinationDescription,
+        () => ExtendedS3DestinationDescription,
+        [() => RedshiftDestinationDescription, 0],
+        () => ElasticsearchDestinationDescription,
+        () => AmazonopensearchserviceDestinationDescription,
+        () => SplunkDestinationDescription,
+        [() => HttpEndpointDestinationDescription, 0],
+        [() => SnowflakeDestinationDescription, 0],
+        () => AmazonOpenSearchServerlessDestinationDescription,
+        () => IcebergDestinationDescription,
+    ],
+];
+var DestinationTableConfiguration = [
+    3,
+    n0,
+    _DTCe,
+    0,
+    [_DTNe, _DDN, _UK, _PS, _SEOP],
+    [0, 0, 64 | 0, () => PartitionSpec, 0],
+];
+var DirectPutSourceConfiguration = [3, n0, _DPSC, 0, [_THIMB], [1]];
+var DirectPutSourceDescription = [3, n0, _DPSD, 0, [_THIMB], [1]];
+var DocumentIdOptions = [3, n0, _DIO, 0, [_DDIF], [0]];
+var DynamicPartitioningConfiguration = [
+    3,
+    n0,
+    _DPC,
+    0,
+    [_RO, _E],
+    [() => RetryOptions, 2],
+];
+var ElasticsearchBufferingHints = [3, n0, _EBH, 0, [_IIS, _SIMB], [1, 1]];
+var ElasticsearchDestinationConfiguration = [
+    3,
+    n0,
+    _EDC,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SBM, _SC, _PC, _CWLO, _VC, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => ElasticsearchBufferingHints,
+        () => ElasticsearchRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfiguration,
+        () => DocumentIdOptions,
+    ],
+];
+var ElasticsearchDestinationDescription = [
+    3,
+    n0,
+    _EDD,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SBM, _SDD, _PC, _CWLO, _VCD, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => ElasticsearchBufferingHints,
+        () => ElasticsearchRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => VpcConfigurationDescription,
+        () => DocumentIdOptions,
+    ],
+];
+var ElasticsearchDestinationUpdate = [
+    3,
+    n0,
+    _EDU,
+    0,
+    [_RARN, _DARN, _CEl, _IN, _TN, _IRP, _BH, _RO, _SUp, _PC, _CWLO, _DIO],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => ElasticsearchBufferingHints,
+        () => ElasticsearchRetryOptions,
+        () => S3DestinationUpdate,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => DocumentIdOptions,
+    ],
+];
+var ElasticsearchRetryOptions = [3, n0, _ERO, 0, [_DIS], [1]];
+var EncryptionConfiguration = [
+    3,
+    n0,
+    _EC,
+    0,
+    [_NEC, _KMSEC],
+    [0, () => KMSEncryptionConfig],
+];
+var ExtendedS3DestinationConfiguration = [
+    3,
+    n0,
+    _ESDC,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO, _PC, _SBM, _SBC, _DFCC, _DPC, _FE, _CTZ],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => BufferingHints,
+        0,
+        () => EncryptionConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationConfiguration,
+        () => DataFormatConversionConfiguration,
+        () => DynamicPartitioningConfiguration,
+        0,
+        0,
+    ],
+];
+var ExtendedS3DestinationDescription = [
+    3,
+    n0,
+    _ESDD,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO, _PC, _SBM, _SBD, _DFCC, _DPC, _FE, _CTZ],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => BufferingHints,
+        0,
+        () => EncryptionConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationDescription,
+        () => DataFormatConversionConfiguration,
+        () => DynamicPartitioningConfiguration,
+        0,
+        0,
+    ],
+];
+var ExtendedS3DestinationUpdate = [
+    3,
+    n0,
+    _ESDU,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO, _PC, _SBM, _SBU, _DFCC, _DPC, _FE, _CTZ],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => BufferingHints,
+        0,
+        () => EncryptionConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationUpdate,
+        () => DataFormatConversionConfiguration,
+        () => DynamicPartitioningConfiguration,
+        0,
+        0,
+    ],
+];
+var FailureDescription = [3, n0, _FD, 0, [_Ty, _Det], [0, 0]];
+var HiveJsonSerDe = [3, n0, _HJSD, 0, [_TF], [64 | 0]];
+var HttpEndpointBufferingHints = [3, n0, _HEBH, 0, [_SIMB, _IIS], [1, 1]];
+var HttpEndpointCommonAttribute = [
+    3,
+    n0,
+    _HECA,
+    0,
+    [_AN, _AV],
+    [
+        [() => HttpEndpointAttributeName, 0],
+        [() => HttpEndpointAttributeValue, 0],
+    ],
+];
+var HttpEndpointConfiguration = [
+    3,
+    n0,
+    _HEC,
+    0,
+    [_Ur, _N, _AK],
+    [[() => HttpEndpointUrl, 0], 0, [() => HttpEndpointAccessKey, 0]],
+];
+var HttpEndpointDescription = [
+    3,
+    n0,
+    _HED,
+    0,
+    [_Ur, _N],
+    [[() => HttpEndpointUrl, 0], 0],
+];
+var HttpEndpointDestinationConfiguration = [
+    3,
+    n0,
+    _HEDC,
+    0,
+    [_ECn, _BH, _CWLO, _RC, _PC, _RARN, _RO, _SBM, _SC, _SMC],
+    [
+        [() => HttpEndpointConfiguration, 0],
+        () => HttpEndpointBufferingHints,
+        () => CloudWatchLoggingOptions,
+        [() => HttpEndpointRequestConfiguration, 0],
+        () => ProcessingConfiguration,
+        0,
+        () => HttpEndpointRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var HttpEndpointDestinationDescription = [
+    3,
+    n0,
+    _HEDD,
+    0,
+    [_ECn, _BH, _CWLO, _RC, _PC, _RARN, _RO, _SBM, _SDD, _SMC],
+    [
+        [() => HttpEndpointDescription, 0],
+        () => HttpEndpointBufferingHints,
+        () => CloudWatchLoggingOptions,
+        [() => HttpEndpointRequestConfiguration, 0],
+        () => ProcessingConfiguration,
+        0,
+        () => HttpEndpointRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var HttpEndpointDestinationUpdate = [
+    3,
+    n0,
+    _HEDU,
+    0,
+    [_ECn, _BH, _CWLO, _RC, _PC, _RARN, _RO, _SBM, _SUp, _SMC],
+    [
+        [() => HttpEndpointConfiguration, 0],
+        () => HttpEndpointBufferingHints,
+        () => CloudWatchLoggingOptions,
+        [() => HttpEndpointRequestConfiguration, 0],
+        () => ProcessingConfiguration,
+        0,
+        () => HttpEndpointRetryOptions,
+        0,
+        () => S3DestinationUpdate,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var HttpEndpointRequestConfiguration = [
+    3,
+    n0,
+    _HERC,
+    0,
+    [_CEo, _CA],
+    [0, [() => HttpEndpointCommonAttributesList, 0]],
+];
+var HttpEndpointRetryOptions = [3, n0, _HERO, 0, [_DIS], [1]];
+var IcebergDestinationConfiguration = [
+    3,
+    n0,
+    _IDC,
+    0,
+    [_DTCL, _SEC, _TCC, _BH, _CWLO, _PC, _SBM, _RO, _RARN, _AO, _CC, _SC],
+    [
+        () => DestinationTableConfigurationList,
+        () => SchemaEvolutionConfiguration,
+        () => TableCreationConfiguration,
+        () => BufferingHints,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => RetryOptions,
+        0,
+        2,
+        () => CatalogConfiguration,
+        () => S3DestinationConfiguration,
+    ],
+];
+var IcebergDestinationDescription = [
+    3,
+    n0,
+    _IDD,
+    0,
+    [_DTCL, _SEC, _TCC, _BH, _CWLO, _PC, _SBM, _RO, _RARN, _AO, _CC, _SDD],
+    [
+        () => DestinationTableConfigurationList,
+        () => SchemaEvolutionConfiguration,
+        () => TableCreationConfiguration,
+        () => BufferingHints,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => RetryOptions,
+        0,
+        2,
+        () => CatalogConfiguration,
+        () => S3DestinationDescription,
+    ],
+];
+var IcebergDestinationUpdate = [
+    3,
+    n0,
+    _IDU,
+    0,
+    [_DTCL, _SEC, _TCC, _BH, _CWLO, _PC, _SBM, _RO, _RARN, _AO, _CC, _SC],
+    [
+        () => DestinationTableConfigurationList,
+        () => SchemaEvolutionConfiguration,
+        () => TableCreationConfiguration,
+        () => BufferingHints,
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => RetryOptions,
+        0,
+        2,
+        () => CatalogConfiguration,
+        () => S3DestinationConfiguration,
+    ],
+];
+var InputFormatConfiguration = [3, n0, _IFC, 0, [_Des], [() => Deserializer]];
+var InvalidArgumentException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArgumentException, InvalidArgumentException$1);
+var InvalidKMSResourceException = [
+    -3,
+    n0,
+    _IKMSRE,
+    {
+        [_e]: _c,
+    },
+    [_co, _m],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidKMSResourceException, InvalidKMSResourceException$1);
+var InvalidSourceException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _c,
+    },
+    [_co, _m],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSourceException, InvalidSourceException$1);
+var KinesisStreamSourceConfiguration = [3, n0, _KSSC, 0, [_KSARN, _RARN], [0, 0]];
+var KinesisStreamSourceDescription = [3, n0, _KSSD, 0, [_KSARN, _RARN, _DSTe], [0, 0, 4]];
+var KMSEncryptionConfig = [3, n0, _KMSEC, 0, [_AWSKMSKARN], [0]];
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListDeliveryStreamsInput = [3, n0, _LDSI, 0, [_L, _DST, _ESDSN], [1, 0, 0]];
+var ListDeliveryStreamsOutput = [3, n0, _LDSO, 0, [_DSNe, _HMDS], [64 | 0, 2]];
+var ListTagsForDeliveryStreamInput = [3, n0, _LTFDSI, 0, [_DSN, _ESTK, _L], [0, 0, 1]];
+var ListTagsForDeliveryStreamOutput = [
+    3,
+    n0,
+    _LTFDSO,
+    0,
+    [_T, _HMT],
+    [() => ListTagsForDeliveryStreamOutputTagList, 2],
+];
+var MSKSourceConfiguration = [
+    3,
+    n0,
+    _MSKSC,
+    0,
+    [_MSKCARN, _TNo, _AC, _RFT],
+    [0, 0, () => AuthenticationConfiguration, 4],
+];
+var MSKSourceDescription = [
+    3,
+    n0,
+    _MSKSD,
+    0,
+    [_MSKCARN, _TNo, _AC, _DSTe, _RFT],
+    [0, 0, () => AuthenticationConfiguration, 4, 4],
+];
+var OpenXJsonSerDe = [3, n0, _OXJSD, 0, [_CDIJKTU, _CI, _CTJKM], [2, 2, 128 | 0]];
+var OrcSerDe = [
+    3,
+    n0,
+    _OSD,
+    0,
+    [_SSB, _BSB, _RIS, _EP, _PT, _Com, _BFC, _BFFPP, _DKT, _FV],
+    [1, 1, 1, 2, 1, 0, 64 | 0, 1, 1, 0],
+];
+var OutputFormatConfiguration = [3, n0, _OFC, 0, [_Se], [() => Serializer]];
+var ParquetSerDe = [
+    3,
+    n0,
+    _PSD,
+    0,
+    [_BSB, _PSB, _Com, _EDCn, _MPB, _WV],
+    [1, 1, 0, 2, 1, 0],
+];
+var PartitionField = [3, n0, _PF, 0, [_SN], [0]];
+var PartitionSpec = [3, n0, _PS, 0, [_Ide], [() => PartitionFields]];
+var ProcessingConfiguration = [3, n0, _PC, 0, [_E, _Pro], [2, () => ProcessorList]];
+var Processor = [3, n0, _Proc, 0, [_Ty, _Pa], [0, () => ProcessorParameterList]];
+var ProcessorParameter = [3, n0, _PP, 0, [_PN, _PV], [0, 0]];
+var PutRecordBatchInput = [
+    3,
+    n0,
+    _PRBI,
+    0,
+    [_DSN, _R],
+    [0, () => PutRecordBatchRequestEntryList],
+];
+var PutRecordBatchOutput = [
+    3,
+    n0,
+    _PRBO,
+    0,
+    [_FPC, _Enc, _RR],
+    [1, 2, () => PutRecordBatchResponseEntryList],
+];
+var PutRecordBatchResponseEntry = [3, n0, _PRBRE, 0, [_RI, _ECr, _EM], [0, 0, 0]];
+var PutRecordInput = [3, n0, _PRI, 0, [_DSN, _Re], [0, () => _Record]];
+var PutRecordOutput = [3, n0, _PRO, 0, [_RI, _Enc], [0, 2]];
+var _Record = [3, n0, _Re, 0, [_Da], [21]];
+var RedshiftDestinationConfiguration = [
+    3,
+    n0,
+    _RDC,
+    0,
+    [_RARN, _CJDBCURL, _CCo, _U, _P, _RO, _SC, _PC, _SBM, _SBC, _CWLO, _SMC],
+    [
+        0,
+        0,
+        () => CopyCommand,
+        [() => Username, 0],
+        [() => Password, 0],
+        () => RedshiftRetryOptions,
+        () => S3DestinationConfiguration,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var RedshiftDestinationDescription = [
+    3,
+    n0,
+    _RDD,
+    0,
+    [_RARN, _CJDBCURL, _CCo, _U, _RO, _SDD, _PC, _SBM, _SBD, _CWLO, _SMC],
+    [
+        0,
+        0,
+        () => CopyCommand,
+        [() => Username, 0],
+        () => RedshiftRetryOptions,
+        () => S3DestinationDescription,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationDescription,
+        () => CloudWatchLoggingOptions,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var RedshiftDestinationUpdate = [
+    3,
+    n0,
+    _RDU,
+    0,
+    [_RARN, _CJDBCURL, _CCo, _U, _P, _RO, _SUp, _PC, _SBM, _SBU, _CWLO, _SMC],
+    [
+        0,
+        0,
+        () => CopyCommand,
+        [() => Username, 0],
+        [() => Password, 0],
+        () => RedshiftRetryOptions,
+        () => S3DestinationUpdate,
+        () => ProcessingConfiguration,
+        0,
+        () => S3DestinationUpdate,
+        () => CloudWatchLoggingOptions,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var RedshiftRetryOptions = [3, n0, _RRO, 0, [_DIS], [1]];
+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 RetryOptions = [3, n0, _RO, 0, [_DIS], [1]];
+var S3DestinationConfiguration = [
+    3,
+    n0,
+    _SDC,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO],
+    [0, 0, 0, 0, () => BufferingHints, 0, () => EncryptionConfiguration, () => CloudWatchLoggingOptions],
+];
+var S3DestinationDescription = [
+    3,
+    n0,
+    _SDD,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO],
+    [0, 0, 0, 0, () => BufferingHints, 0, () => EncryptionConfiguration, () => CloudWatchLoggingOptions],
+];
+var S3DestinationUpdate = [
+    3,
+    n0,
+    _SDU,
+    0,
+    [_RARN, _BARN, _Pr, _EOP, _BH, _CF, _EC, _CWLO],
+    [0, 0, 0, 0, () => BufferingHints, 0, () => EncryptionConfiguration, () => CloudWatchLoggingOptions],
+];
+var SchemaConfiguration = [
+    3,
+    n0,
+    _SCc,
+    0,
+    [_RARN, _CIa, _DN, _TNa, _Reg, _VI],
+    [0, 0, 0, 0, 0, 0],
+];
+var SchemaEvolutionConfiguration = [3, n0, _SEC, 0, [_E], [2]];
+var SecretsManagerConfiguration = [3, n0, _SMC, 0, [_SARN, _RARN, _E], [0, 0, 2]];
+var Serializer = [3, n0, _Se, 0, [_PSD, _OSD], [() => ParquetSerDe, () => OrcSerDe]];
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_e]: _s,
+        [_hE]: 503,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var SnowflakeBufferingHints = [3, n0, _SBH, 0, [_SIMB, _IIS], [1, 1]];
+var SnowflakeDestinationConfiguration = [
+    3,
+    n0,
+    _SDCn,
+    0,
+    [_AU, _PK, _KP, _Us, _Dat, _Sc, _Ta, _SRC, _DLO, _MDCN, _CCN, _SVC, _CWLO, _PC, _RARN, _RO, _SBM, _SC, _SMC, _BH],
+    [
+        [() => SnowflakeAccountUrl, 0],
+        [() => SnowflakePrivateKey, 0],
+        [() => SnowflakeKeyPassphrase, 0],
+        [() => SnowflakeUser, 0],
+        [() => SnowflakeDatabase, 0],
+        [() => SnowflakeSchema, 0],
+        [() => SnowflakeTable, 0],
+        [() => SnowflakeRoleConfiguration, 0],
+        0,
+        [() => SnowflakeMetaDataColumnName, 0],
+        [() => SnowflakeContentColumnName, 0],
+        [() => SnowflakeVpcConfiguration, 0],
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => SnowflakeRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => SecretsManagerConfiguration,
+        () => SnowflakeBufferingHints,
+    ],
+];
+var SnowflakeDestinationDescription = [
+    3,
+    n0,
+    _SDDn,
+    0,
+    [_AU, _Us, _Dat, _Sc, _Ta, _SRC, _DLO, _MDCN, _CCN, _SVC, _CWLO, _PC, _RARN, _RO, _SBM, _SDD, _SMC, _BH],
+    [
+        [() => SnowflakeAccountUrl, 0],
+        [() => SnowflakeUser, 0],
+        [() => SnowflakeDatabase, 0],
+        [() => SnowflakeSchema, 0],
+        [() => SnowflakeTable, 0],
+        [() => SnowflakeRoleConfiguration, 0],
+        0,
+        [() => SnowflakeMetaDataColumnName, 0],
+        [() => SnowflakeContentColumnName, 0],
+        [() => SnowflakeVpcConfiguration, 0],
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => SnowflakeRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => SecretsManagerConfiguration,
+        () => SnowflakeBufferingHints,
+    ],
+];
+var SnowflakeDestinationUpdate = [
+    3,
+    n0,
+    _SDUn,
+    0,
+    [_AU, _PK, _KP, _Us, _Dat, _Sc, _Ta, _SRC, _DLO, _MDCN, _CCN, _CWLO, _PC, _RARN, _RO, _SBM, _SUp, _SMC, _BH],
+    [
+        [() => SnowflakeAccountUrl, 0],
+        [() => SnowflakePrivateKey, 0],
+        [() => SnowflakeKeyPassphrase, 0],
+        [() => SnowflakeUser, 0],
+        [() => SnowflakeDatabase, 0],
+        [() => SnowflakeSchema, 0],
+        [() => SnowflakeTable, 0],
+        [() => SnowflakeRoleConfiguration, 0],
+        0,
+        [() => SnowflakeMetaDataColumnName, 0],
+        [() => SnowflakeContentColumnName, 0],
+        () => CloudWatchLoggingOptions,
+        () => ProcessingConfiguration,
+        0,
+        () => SnowflakeRetryOptions,
+        0,
+        () => S3DestinationUpdate,
+        () => SecretsManagerConfiguration,
+        () => SnowflakeBufferingHints,
+    ],
+];
+var SnowflakeRetryOptions = [3, n0, _SRO, 0, [_DIS], [1]];
+var SnowflakeRoleConfiguration = [
+    3,
+    n0,
+    _SRC,
+    0,
+    [_E, _SR],
+    [2, [() => SnowflakeRole, 0]],
+];
+var SnowflakeVpcConfiguration = [
+    3,
+    n0,
+    _SVC,
+    0,
+    [_PLVI],
+    [[() => SnowflakePrivateLinkVpceId, 0]],
+];
+var SourceDescription = [
+    3,
+    n0,
+    _SDo,
+    0,
+    [_DPSD, _KSSD, _MSKSD, _DSD],
+    [
+        () => DirectPutSourceDescription,
+        () => KinesisStreamSourceDescription,
+        () => MSKSourceDescription,
+        () => DatabaseSourceDescription,
+    ],
+];
+var SplunkBufferingHints = [3, n0, _SBHp, 0, [_IIS, _SIMB], [1, 1]];
+var SplunkDestinationConfiguration = [
+    3,
+    n0,
+    _SDCp,
+    0,
+    [_HECE, _HECET, _HECT, _HECATIS, _RO, _SBM, _SC, _PC, _CWLO, _BH, _SMC],
+    [
+        0,
+        0,
+        0,
+        1,
+        () => SplunkRetryOptions,
+        0,
+        () => S3DestinationConfiguration,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => SplunkBufferingHints,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var SplunkDestinationDescription = [
+    3,
+    n0,
+    _SDDp,
+    0,
+    [_HECE, _HECET, _HECT, _HECATIS, _RO, _SBM, _SDD, _PC, _CWLO, _BH, _SMC],
+    [
+        0,
+        0,
+        0,
+        1,
+        () => SplunkRetryOptions,
+        0,
+        () => S3DestinationDescription,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => SplunkBufferingHints,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var SplunkDestinationUpdate = [
+    3,
+    n0,
+    _SDUp,
+    0,
+    [_HECE, _HECET, _HECT, _HECATIS, _RO, _SBM, _SUp, _PC, _CWLO, _BH, _SMC],
+    [
+        0,
+        0,
+        0,
+        1,
+        () => SplunkRetryOptions,
+        0,
+        () => S3DestinationUpdate,
+        () => ProcessingConfiguration,
+        () => CloudWatchLoggingOptions,
+        () => SplunkBufferingHints,
+        () => SecretsManagerConfiguration,
+    ],
+];
+var SplunkRetryOptions = [3, n0, _SROp, 0, [_DIS], [1]];
+var StartDeliveryStreamEncryptionInput = [
+    3,
+    n0,
+    _SDSEI,
+    0,
+    [_DSN, _DSECI],
+    [0, () => DeliveryStreamEncryptionConfigurationInput],
+];
+var StartDeliveryStreamEncryptionOutput = [3, n0, _SDSEO, 0, [], []];
+var StopDeliveryStreamEncryptionInput = [3, n0, _SDSEIt, 0, [_DSN], [0]];
+var StopDeliveryStreamEncryptionOutput = [3, n0, _SDSEOt, 0, [], []];
+var TableCreationConfiguration = [3, n0, _TCC, 0, [_E], [2]];
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagDeliveryStreamInput = [
+    3,
+    n0,
+    _TDSI,
+    0,
+    [_DSN, _T],
+    [0, () => TagDeliveryStreamInputTagList],
+];
+var TagDeliveryStreamOutput = [3, n0, _TDSO, 0, [], []];
+var UntagDeliveryStreamInput = [3, n0, _UDSI, 0, [_DSN, _TK], [0, 64 | 0]];
+var UntagDeliveryStreamOutput = [3, n0, _UDSO, 0, [], []];
+var UpdateDestinationInput = [
+    3,
+    n0,
+    _UDI,
+    0,
+    [_DSN, _CDSVI, _DI, _SDU, _ESDU, _RDU, _EDU, _ADU, _SDUp, _HEDU, _AOSSDU, _SDUn, _IDU],
+    [
+        0,
+        0,
+        0,
+        () => S3DestinationUpdate,
+        () => ExtendedS3DestinationUpdate,
+        [() => RedshiftDestinationUpdate, 0],
+        () => ElasticsearchDestinationUpdate,
+        () => AmazonopensearchserviceDestinationUpdate,
+        () => SplunkDestinationUpdate,
+        [() => HttpEndpointDestinationUpdate, 0],
+        () => AmazonOpenSearchServerlessDestinationUpdate,
+        [() => SnowflakeDestinationUpdate, 0],
+        () => IcebergDestinationUpdate,
+    ],
+];
+var UpdateDestinationOutput = [3, n0, _UDO, 0, [], []];
+var VpcConfiguration = [3, n0, _VC, 0, [_SIu, _RARN, _SGI], [64 | 0, 0, 64 | 0]];
+var VpcConfigurationDescription = [
+    3,
+    n0,
+    _VCD,
+    0,
+    [_SIu, _RARN, _SGI, _VIp],
+    [64 | 0, 0, 64 | 0, 0],
+];
+var FirehoseServiceException = [-3, _sm, "FirehoseServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(FirehoseServiceException, FirehoseServiceException$1);
+var DatabaseSnapshotInfoList = [1, n0, _DSIL, 0, () => DatabaseSnapshotInfo];
+var DestinationDescriptionList = [1, n0, _DDL, 0, [() => DestinationDescription, 0]];
+var DestinationTableConfigurationList = [1, n0, _DTCL, 0, () => DestinationTableConfiguration];
+var HttpEndpointCommonAttributesList = [
+    1,
+    n0,
+    _HECAL,
+    0,
+    [() => HttpEndpointCommonAttribute, 0],
+];
+var ListTagsForDeliveryStreamOutputTagList = [1, n0, _LTFDSOTL, 0, () => Tag];
+var PartitionFields = [1, n0, _PFa, 0, () => PartitionField];
+var ProcessorList = [1, n0, _PL, 0, () => Processor];
+var ProcessorParameterList = [1, n0, _PPL, 0, () => ProcessorParameter];
+var PutRecordBatchRequestEntryList = [1, n0, _PRBREL, 0, () => _Record];
+var PutRecordBatchResponseEntryList = [1, n0, _PRBRELu, 0, () => PutRecordBatchResponseEntry];
+var TagDeliveryStreamInputTagList = [1, n0, _TDSITL, 0, () => Tag];
+var CreateDeliveryStream = [
+    9,
+    n0,
+    _CDS,
+    0,
+    () => CreateDeliveryStreamInput,
+    () => CreateDeliveryStreamOutput,
+];
+var DeleteDeliveryStream = [
+    9,
+    n0,
+    _DDS,
+    0,
+    () => DeleteDeliveryStreamInput,
+    () => DeleteDeliveryStreamOutput,
+];
+var DescribeDeliveryStream = [
+    9,
+    n0,
+    _DDSe,
+    0,
+    () => DescribeDeliveryStreamInput,
+    () => DescribeDeliveryStreamOutput,
+];
+var ListDeliveryStreams = [
+    9,
+    n0,
+    _LDS,
+    0,
+    () => ListDeliveryStreamsInput,
+    () => ListDeliveryStreamsOutput,
+];
+var ListTagsForDeliveryStream = [
+    9,
+    n0,
+    _LTFDS,
+    0,
+    () => ListTagsForDeliveryStreamInput,
+    () => ListTagsForDeliveryStreamOutput,
+];
+var PutRecord = [9, n0, _PR, 0, () => PutRecordInput, () => PutRecordOutput];
+var PutRecordBatch = [
+    9,
+    n0,
+    _PRB,
+    0,
+    () => PutRecordBatchInput,
+    () => PutRecordBatchOutput,
+];
+var StartDeliveryStreamEncryption = [
+    9,
+    n0,
+    _SDSE,
+    0,
+    () => StartDeliveryStreamEncryptionInput,
+    () => StartDeliveryStreamEncryptionOutput,
+];
+var StopDeliveryStreamEncryption = [
+    9,
+    n0,
+    _SDSEt,
+    0,
+    () => StopDeliveryStreamEncryptionInput,
+    () => StopDeliveryStreamEncryptionOutput,
+];
+var TagDeliveryStream = [
+    9,
+    n0,
+    _TDS,
+    0,
+    () => TagDeliveryStreamInput,
+    () => TagDeliveryStreamOutput,
+];
+var UntagDeliveryStream = [
+    9,
+    n0,
+    _UDS,
+    0,
+    () => UntagDeliveryStreamInput,
+    () => UntagDeliveryStreamOutput,
+];
+var UpdateDestination = [
+    9,
+    n0,
+    _UD,
+    0,
+    () => UpdateDestinationInput,
+    () => UpdateDestinationOutput,
+];
 
 class CreateDeliveryStreamCommand 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("Firehose_20150804", "CreateDeliveryStream", {})
     .n("FirehoseClient", "CreateDeliveryStreamCommand")
-    .f(CreateDeliveryStreamInputFilterSensitiveLog, void 0)
-    .ser(se_CreateDeliveryStreamCommand)
-    .de(de_CreateDeliveryStreamCommand)
+    .sc(CreateDeliveryStream)
     .build() {
 }
 
@@ -1248,16 +2016,11 @@ class DeleteDeliveryStreamCommand 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("Firehose_20150804", "DeleteDeliveryStream", {})
     .n("FirehoseClient", "DeleteDeliveryStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDeliveryStreamCommand)
-    .de(de_DeleteDeliveryStreamCommand)
+    .sc(DeleteDeliveryStream)
     .build() {
 }
 
@@ -1265,16 +2028,11 @@ class DescribeDeliveryStreamCommand 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("Firehose_20150804", "DescribeDeliveryStream", {})
     .n("FirehoseClient", "DescribeDeliveryStreamCommand")
-    .f(void 0, DescribeDeliveryStreamOutputFilterSensitiveLog)
-    .ser(se_DescribeDeliveryStreamCommand)
-    .de(de_DescribeDeliveryStreamCommand)
+    .sc(DescribeDeliveryStream)
     .build() {
 }
 
@@ -1282,16 +2040,11 @@ class ListDeliveryStreamsCommand 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("Firehose_20150804", "ListDeliveryStreams", {})
     .n("FirehoseClient", "ListDeliveryStreamsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDeliveryStreamsCommand)
-    .de(de_ListDeliveryStreamsCommand)
+    .sc(ListDeliveryStreams)
     .build() {
 }
 
@@ -1299,16 +2052,11 @@ class ListTagsForDeliveryStreamCommand 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("Firehose_20150804", "ListTagsForDeliveryStream", {})
     .n("FirehoseClient", "ListTagsForDeliveryStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForDeliveryStreamCommand)
-    .de(de_ListTagsForDeliveryStreamCommand)
+    .sc(ListTagsForDeliveryStream)
     .build() {
 }
 
@@ -1316,16 +2064,11 @@ class PutRecordBatchCommand 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("Firehose_20150804", "PutRecordBatch", {})
     .n("FirehoseClient", "PutRecordBatchCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRecordBatchCommand)
-    .de(de_PutRecordBatchCommand)
+    .sc(PutRecordBatch)
     .build() {
 }
 
@@ -1333,16 +2076,11 @@ class PutRecordCommand 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("Firehose_20150804", "PutRecord", {})
     .n("FirehoseClient", "PutRecordCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRecordCommand)
-    .de(de_PutRecordCommand)
+    .sc(PutRecord)
     .build() {
 }
 
@@ -1350,16 +2088,11 @@ class StartDeliveryStreamEncryptionCommand 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("Firehose_20150804", "StartDeliveryStreamEncryption", {})
     .n("FirehoseClient", "StartDeliveryStreamEncryptionCommand")
-    .f(void 0, void 0)
-    .ser(se_StartDeliveryStreamEncryptionCommand)
-    .de(de_StartDeliveryStreamEncryptionCommand)
+    .sc(StartDeliveryStreamEncryption)
     .build() {
 }
 
@@ -1367,16 +2100,11 @@ class StopDeliveryStreamEncryptionCommand 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("Firehose_20150804", "StopDeliveryStreamEncryption", {})
     .n("FirehoseClient", "StopDeliveryStreamEncryptionCommand")
-    .f(void 0, void 0)
-    .ser(se_StopDeliveryStreamEncryptionCommand)
-    .de(de_StopDeliveryStreamEncryptionCommand)
+    .sc(StopDeliveryStreamEncryption)
     .build() {
 }
 
@@ -1384,16 +2112,11 @@ class TagDeliveryStreamCommand 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("Firehose_20150804", "TagDeliveryStream", {})
     .n("FirehoseClient", "TagDeliveryStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_TagDeliveryStreamCommand)
-    .de(de_TagDeliveryStreamCommand)
+    .sc(TagDeliveryStream)
     .build() {
 }
 
@@ -1401,16 +2124,11 @@ class UntagDeliveryStreamCommand 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("Firehose_20150804", "UntagDeliveryStream", {})
     .n("FirehoseClient", "UntagDeliveryStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagDeliveryStreamCommand)
-    .de(de_UntagDeliveryStreamCommand)
+    .sc(UntagDeliveryStream)
     .build() {
 }
 
@@ -1418,16 +2136,11 @@ class UpdateDestinationCommand 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("Firehose_20150804", "UpdateDestination", {})
     .n("FirehoseClient", "UpdateDestinationCommand")
-    .f(UpdateDestinationInputFilterSensitiveLog, void 0)
-    .ser(se_UpdateDestinationCommand)
-    .de(de_UpdateDestinationCommand)
+    .sc(UpdateDestination)
     .build() {
 }
 
@@ -1461,42 +2174,31 @@ exports.AmazonOpenSearchServerlessS3BackupMode = AmazonOpenSearchServerlessS3Bac
 exports.AmazonopensearchserviceIndexRotationPeriod = AmazonopensearchserviceIndexRotationPeriod;
 exports.AmazonopensearchserviceS3BackupMode = AmazonopensearchserviceS3BackupMode;
 exports.CompressionFormat = CompressionFormat;
-exports.ConcurrentModificationException = ConcurrentModificationException;
+exports.ConcurrentModificationException = ConcurrentModificationException$1;
 exports.Connectivity = Connectivity;
 exports.ContentEncoding = ContentEncoding;
 exports.CreateDeliveryStreamCommand = CreateDeliveryStreamCommand;
-exports.CreateDeliveryStreamInputFilterSensitiveLog = CreateDeliveryStreamInputFilterSensitiveLog;
 exports.DatabaseType = DatabaseType;
 exports.DefaultDocumentIdFormat = DefaultDocumentIdFormat;
 exports.DeleteDeliveryStreamCommand = DeleteDeliveryStreamCommand;
-exports.DeliveryStreamDescriptionFilterSensitiveLog = DeliveryStreamDescriptionFilterSensitiveLog;
 exports.DeliveryStreamEncryptionStatus = DeliveryStreamEncryptionStatus;
 exports.DeliveryStreamFailureType = DeliveryStreamFailureType;
 exports.DeliveryStreamStatus = DeliveryStreamStatus;
 exports.DeliveryStreamType = DeliveryStreamType;
 exports.DescribeDeliveryStreamCommand = DescribeDeliveryStreamCommand;
-exports.DescribeDeliveryStreamOutputFilterSensitiveLog = DescribeDeliveryStreamOutputFilterSensitiveLog;
-exports.DestinationDescriptionFilterSensitiveLog = DestinationDescriptionFilterSensitiveLog;
 exports.ElasticsearchIndexRotationPeriod = ElasticsearchIndexRotationPeriod;
 exports.ElasticsearchS3BackupMode = ElasticsearchS3BackupMode;
 exports.Firehose = Firehose;
 exports.FirehoseClient = FirehoseClient;
-exports.FirehoseServiceException = FirehoseServiceException;
+exports.FirehoseServiceException = FirehoseServiceException$1;
 exports.HECEndpointType = HECEndpointType;
-exports.HttpEndpointCommonAttributeFilterSensitiveLog = HttpEndpointCommonAttributeFilterSensitiveLog;
-exports.HttpEndpointConfigurationFilterSensitiveLog = HttpEndpointConfigurationFilterSensitiveLog;
-exports.HttpEndpointDescriptionFilterSensitiveLog = HttpEndpointDescriptionFilterSensitiveLog;
-exports.HttpEndpointDestinationConfigurationFilterSensitiveLog = HttpEndpointDestinationConfigurationFilterSensitiveLog;
-exports.HttpEndpointDestinationDescriptionFilterSensitiveLog = HttpEndpointDestinationDescriptionFilterSensitiveLog;
-exports.HttpEndpointDestinationUpdateFilterSensitiveLog = HttpEndpointDestinationUpdateFilterSensitiveLog;
-exports.HttpEndpointRequestConfigurationFilterSensitiveLog = HttpEndpointRequestConfigurationFilterSensitiveLog;
 exports.HttpEndpointS3BackupMode = HttpEndpointS3BackupMode;
 exports.IcebergS3BackupMode = IcebergS3BackupMode;
-exports.InvalidArgumentException = InvalidArgumentException;
-exports.InvalidKMSResourceException = InvalidKMSResourceException;
-exports.InvalidSourceException = InvalidSourceException;
+exports.InvalidArgumentException = InvalidArgumentException$1;
+exports.InvalidKMSResourceException = InvalidKMSResourceException$1;
+exports.InvalidSourceException = InvalidSourceException$1;
 exports.KeyType = KeyType;
-exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListDeliveryStreamsCommand = ListDeliveryStreamsCommand;
 exports.ListTagsForDeliveryStreamCommand = ListTagsForDeliveryStreamCommand;
 exports.NoEncryptionConfig = NoEncryptionConfig;
@@ -1508,28 +2210,19 @@ exports.ProcessorParameterName = ProcessorParameterName;
 exports.ProcessorType = ProcessorType;
 exports.PutRecordBatchCommand = PutRecordBatchCommand;
 exports.PutRecordCommand = PutRecordCommand;
-exports.RedshiftDestinationConfigurationFilterSensitiveLog = RedshiftDestinationConfigurationFilterSensitiveLog;
-exports.RedshiftDestinationDescriptionFilterSensitiveLog = RedshiftDestinationDescriptionFilterSensitiveLog;
-exports.RedshiftDestinationUpdateFilterSensitiveLog = RedshiftDestinationUpdateFilterSensitiveLog;
 exports.RedshiftS3BackupMode = RedshiftS3BackupMode;
-exports.ResourceInUseException = ResourceInUseException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceInUseException = ResourceInUseException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.S3BackupMode = S3BackupMode;
 exports.SSLMode = SSLMode;
-exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
 exports.SnapshotRequestedBy = SnapshotRequestedBy;
 exports.SnapshotStatus = SnapshotStatus;
 exports.SnowflakeDataLoadingOption = SnowflakeDataLoadingOption;
-exports.SnowflakeDestinationConfigurationFilterSensitiveLog = SnowflakeDestinationConfigurationFilterSensitiveLog;
-exports.SnowflakeDestinationDescriptionFilterSensitiveLog = SnowflakeDestinationDescriptionFilterSensitiveLog;
-exports.SnowflakeDestinationUpdateFilterSensitiveLog = SnowflakeDestinationUpdateFilterSensitiveLog;
-exports.SnowflakeRoleConfigurationFilterSensitiveLog = SnowflakeRoleConfigurationFilterSensitiveLog;
 exports.SnowflakeS3BackupMode = SnowflakeS3BackupMode;
-exports.SnowflakeVpcConfigurationFilterSensitiveLog = SnowflakeVpcConfigurationFilterSensitiveLog;
 exports.SplunkS3BackupMode = SplunkS3BackupMode;
 exports.StartDeliveryStreamEncryptionCommand = StartDeliveryStreamEncryptionCommand;
 exports.StopDeliveryStreamEncryptionCommand = StopDeliveryStreamEncryptionCommand;
 exports.TagDeliveryStreamCommand = TagDeliveryStreamCommand;
 exports.UntagDeliveryStreamCommand = UntagDeliveryStreamCommand;
 exports.UpdateDestinationCommand = UpdateDestinationCommand;
-exports.UpdateDestinationInputFilterSensitiveLog = UpdateDestinationInputFilterSensitiveLog;