@aws-sdk/client-firehose 3.899.0 → 3.906.0

package/dist-cjs/index.js

@@ -1,1724 +1,1535 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AmazonOpenSearchServerlessS3BackupMode: () => AmazonOpenSearchServerlessS3BackupMode,
-  AmazonopensearchserviceIndexRotationPeriod: () => AmazonopensearchserviceIndexRotationPeriod,
-  AmazonopensearchserviceS3BackupMode: () => AmazonopensearchserviceS3BackupMode,
-  CompressionFormat: () => CompressionFormat,
-  ConcurrentModificationException: () => ConcurrentModificationException,
-  Connectivity: () => Connectivity,
-  ContentEncoding: () => ContentEncoding,
-  CreateDeliveryStreamCommand: () => CreateDeliveryStreamCommand,
-  CreateDeliveryStreamInputFilterSensitiveLog: () => CreateDeliveryStreamInputFilterSensitiveLog,
-  DatabaseType: () => DatabaseType,
-  DefaultDocumentIdFormat: () => DefaultDocumentIdFormat,
-  DeleteDeliveryStreamCommand: () => DeleteDeliveryStreamCommand,
-  DeliveryStreamDescriptionFilterSensitiveLog: () => DeliveryStreamDescriptionFilterSensitiveLog,
-  DeliveryStreamEncryptionStatus: () => DeliveryStreamEncryptionStatus,
-  DeliveryStreamFailureType: () => DeliveryStreamFailureType,
-  DeliveryStreamStatus: () => DeliveryStreamStatus,
-  DeliveryStreamType: () => DeliveryStreamType,
-  DescribeDeliveryStreamCommand: () => DescribeDeliveryStreamCommand,
-  DescribeDeliveryStreamOutputFilterSensitiveLog: () => DescribeDeliveryStreamOutputFilterSensitiveLog,
-  DestinationDescriptionFilterSensitiveLog: () => DestinationDescriptionFilterSensitiveLog,
-  ElasticsearchIndexRotationPeriod: () => ElasticsearchIndexRotationPeriod,
-  ElasticsearchS3BackupMode: () => ElasticsearchS3BackupMode,
-  Firehose: () => Firehose,
-  FirehoseClient: () => FirehoseClient,
-  FirehoseServiceException: () => FirehoseServiceException,
-  HECEndpointType: () => HECEndpointType,
-  HttpEndpointCommonAttributeFilterSensitiveLog: () => HttpEndpointCommonAttributeFilterSensitiveLog,
-  HttpEndpointConfigurationFilterSensitiveLog: () => HttpEndpointConfigurationFilterSensitiveLog,
-  HttpEndpointDescriptionFilterSensitiveLog: () => HttpEndpointDescriptionFilterSensitiveLog,
-  HttpEndpointDestinationConfigurationFilterSensitiveLog: () => HttpEndpointDestinationConfigurationFilterSensitiveLog,
-  HttpEndpointDestinationDescriptionFilterSensitiveLog: () => HttpEndpointDestinationDescriptionFilterSensitiveLog,
-  HttpEndpointDestinationUpdateFilterSensitiveLog: () => HttpEndpointDestinationUpdateFilterSensitiveLog,
-  HttpEndpointRequestConfigurationFilterSensitiveLog: () => HttpEndpointRequestConfigurationFilterSensitiveLog,
-  HttpEndpointS3BackupMode: () => HttpEndpointS3BackupMode,
-  IcebergS3BackupMode: () => IcebergS3BackupMode,
-  InvalidArgumentException: () => InvalidArgumentException,
-  InvalidKMSResourceException: () => InvalidKMSResourceException,
-  InvalidSourceException: () => InvalidSourceException,
-  KeyType: () => KeyType,
-  LimitExceededException: () => LimitExceededException,
-  ListDeliveryStreamsCommand: () => ListDeliveryStreamsCommand,
-  ListTagsForDeliveryStreamCommand: () => ListTagsForDeliveryStreamCommand,
-  NoEncryptionConfig: () => NoEncryptionConfig,
-  OrcCompression: () => OrcCompression,
-  OrcFormatVersion: () => OrcFormatVersion,
-  ParquetCompression: () => ParquetCompression,
-  ParquetWriterVersion: () => ParquetWriterVersion,
-  ProcessorParameterName: () => ProcessorParameterName,
-  ProcessorType: () => ProcessorType,
-  PutRecordBatchCommand: () => PutRecordBatchCommand,
-  PutRecordCommand: () => PutRecordCommand,
-  RedshiftDestinationConfigurationFilterSensitiveLog: () => RedshiftDestinationConfigurationFilterSensitiveLog,
-  RedshiftDestinationDescriptionFilterSensitiveLog: () => RedshiftDestinationDescriptionFilterSensitiveLog,
-  RedshiftDestinationUpdateFilterSensitiveLog: () => RedshiftDestinationUpdateFilterSensitiveLog,
-  RedshiftS3BackupMode: () => RedshiftS3BackupMode,
-  ResourceInUseException: () => ResourceInUseException,
-  ResourceNotFoundException: () => ResourceNotFoundException,
-  S3BackupMode: () => S3BackupMode,
-  SSLMode: () => SSLMode,
-  ServiceUnavailableException: () => ServiceUnavailableException,
-  SnapshotRequestedBy: () => SnapshotRequestedBy,
-  SnapshotStatus: () => SnapshotStatus,
-  SnowflakeDataLoadingOption: () => SnowflakeDataLoadingOption,
-  SnowflakeDestinationConfigurationFilterSensitiveLog: () => SnowflakeDestinationConfigurationFilterSensitiveLog,
-  SnowflakeDestinationDescriptionFilterSensitiveLog: () => SnowflakeDestinationDescriptionFilterSensitiveLog,
-  SnowflakeDestinationUpdateFilterSensitiveLog: () => SnowflakeDestinationUpdateFilterSensitiveLog,
-  SnowflakeRoleConfigurationFilterSensitiveLog: () => SnowflakeRoleConfigurationFilterSensitiveLog,
-  SnowflakeS3BackupMode: () => SnowflakeS3BackupMode,
-  SnowflakeVpcConfigurationFilterSensitiveLog: () => SnowflakeVpcConfigurationFilterSensitiveLog,
-  SplunkS3BackupMode: () => SplunkS3BackupMode,
-  StartDeliveryStreamEncryptionCommand: () => StartDeliveryStreamEncryptionCommand,
-  StopDeliveryStreamEncryptionCommand: () => StopDeliveryStreamEncryptionCommand,
-  TagDeliveryStreamCommand: () => TagDeliveryStreamCommand,
-  UntagDeliveryStreamCommand: () => UntagDeliveryStreamCommand,
-  UpdateDestinationCommand: () => UpdateDestinationCommand,
-  UpdateDestinationInputFilterSensitiveLog: () => UpdateDestinationInputFilterSensitiveLog,
-  __Client: () => import_smithy_client.Client
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/FirehoseClient.ts
-var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
-var import_middleware_logger = require("@aws-sdk/middleware-logger");
-var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
-var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-var import_middleware_content_length = require("@smithy/middleware-content-length");
-var import_middleware_endpoint = require("@smithy/middleware-endpoint");
-var import_middleware_retry = require("@smithy/middleware-retry");
-
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(options, {
-    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
-    useFipsEndpoint: options.useFipsEndpoint ?? false,
-    defaultSigningName: "firehose"
-  });
-}, "resolveClientEndpointParameters");
-var commonParams = {
-  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-  Endpoint: { type: "builtInParams", name: "endpoint" },
-  Region: { type: "builtInParams", name: "region" },
-  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+'use strict';
+
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+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, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "firehose",
+    });
+};
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
-// src/FirehoseClient.ts
-var import_runtimeConfig = require("././runtimeConfig");
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
 
-// src/runtimeExtensions.ts
-var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
-var import_protocol_http = require("@smithy/protocol-http");
-var import_smithy_client = require("@smithy/smithy-client");
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
 
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+class FirehoseClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultFirehoseHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+    destroy() {
+        super.destroy();
+    }
+}
 
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
+class FirehoseServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, FirehoseServiceException.prototype);
+    }
+}
 
-// src/FirehoseClient.ts
-var FirehoseClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "FirehoseClient");
-  }
-  /**
-   * The resolved configuration of FirehoseClient class. This is resolved and normalized from the {@link FirehoseClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
-    this.middlewareStack.use(
-      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultFirehoseHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
-  }
-  /**
-   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-   */
-  destroy() {
-    super.destroy();
-  }
+const ProcessorParameterName = {
+    BUFFER_INTERVAL_IN_SECONDS: "BufferIntervalInSeconds",
+    BUFFER_SIZE_IN_MB: "BufferSizeInMBs",
+    COMPRESSION_FORMAT: "CompressionFormat",
+    DATA_MESSAGE_EXTRACTION: "DataMessageExtraction",
+    Delimiter: "Delimiter",
+    JSON_PARSING_ENGINE: "JsonParsingEngine",
+    LAMBDA_ARN: "LambdaArn",
+    LAMBDA_NUMBER_OF_RETRIES: "NumberOfRetries",
+    METADATA_EXTRACTION_QUERY: "MetadataExtractionQuery",
+    ROLE_ARN: "RoleArn",
+    SUB_RECORD_TYPE: "SubRecordType",
 };
-
-// src/Firehose.ts
-
-
-// src/commands/CreateDeliveryStreamCommand.ts
-
-var import_middleware_serde = require("@smithy/middleware-serde");
-
-
-// src/models/models_0.ts
-
-
-// src/models/FirehoseServiceException.ts
-
-var FirehoseServiceException = class _FirehoseServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "FirehoseServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _FirehoseServiceException.prototype);
-  }
+const ProcessorType = {
+    AppendDelimiterToRecord: "AppendDelimiterToRecord",
+    CloudWatchLogProcessing: "CloudWatchLogProcessing",
+    Decompression: "Decompression",
+    Lambda: "Lambda",
+    MetadataExtraction: "MetadataExtraction",
+    RecordDeAggregation: "RecordDeAggregation",
+};
+const AmazonOpenSearchServerlessS3BackupMode = {
+    AllDocuments: "AllDocuments",
+    FailedDocumentsOnly: "FailedDocumentsOnly",
+};
+const CompressionFormat = {
+    GZIP: "GZIP",
+    HADOOP_SNAPPY: "HADOOP_SNAPPY",
+    SNAPPY: "Snappy",
+    UNCOMPRESSED: "UNCOMPRESSED",
+    ZIP: "ZIP",
+};
+const NoEncryptionConfig = {
+    NoEncryption: "NoEncryption",
+};
+const DefaultDocumentIdFormat = {
+    FIREHOSE_DEFAULT: "FIREHOSE_DEFAULT",
+    NO_DOCUMENT_ID: "NO_DOCUMENT_ID",
+};
+const AmazonopensearchserviceIndexRotationPeriod = {
+    NoRotation: "NoRotation",
+    OneDay: "OneDay",
+    OneHour: "OneHour",
+    OneMonth: "OneMonth",
+    OneWeek: "OneWeek",
+};
+const AmazonopensearchserviceS3BackupMode = {
+    AllDocuments: "AllDocuments",
+    FailedDocumentsOnly: "FailedDocumentsOnly",
+};
+const Connectivity = {
+    PRIVATE: "PRIVATE",
+    PUBLIC: "PUBLIC",
+};
+class ConcurrentModificationException extends FirehoseServiceException {
+    name = "ConcurrentModificationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+    }
+}
+const ContentEncoding = {
+    GZIP: "GZIP",
+    NONE: "NONE",
+};
+const SSLMode = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const DatabaseType = {
+    MySQL: "MySQL",
+    PostgreSQL: "PostgreSQL",
+};
+const KeyType = {
+    AWS_OWNED_CMK: "AWS_OWNED_CMK",
+    CUSTOMER_MANAGED_CMK: "CUSTOMER_MANAGED_CMK",
+};
+const DeliveryStreamType = {
+    DatabaseAsSource: "DatabaseAsSource",
+    DirectPut: "DirectPut",
+    KinesisStreamAsSource: "KinesisStreamAsSource",
+    MSKAsSource: "MSKAsSource",
+};
+const ElasticsearchIndexRotationPeriod = {
+    NoRotation: "NoRotation",
+    OneDay: "OneDay",
+    OneHour: "OneHour",
+    OneMonth: "OneMonth",
+    OneWeek: "OneWeek",
+};
+const ElasticsearchS3BackupMode = {
+    AllDocuments: "AllDocuments",
+    FailedDocumentsOnly: "FailedDocumentsOnly",
+};
+const OrcCompression = {
+    NONE: "NONE",
+    SNAPPY: "SNAPPY",
+    ZLIB: "ZLIB",
+};
+const OrcFormatVersion = {
+    V0_11: "V0_11",
+    V0_12: "V0_12",
+};
+const ParquetCompression = {
+    GZIP: "GZIP",
+    SNAPPY: "SNAPPY",
+    UNCOMPRESSED: "UNCOMPRESSED",
+};
+const ParquetWriterVersion = {
+    V1: "V1",
+    V2: "V2",
+};
+const S3BackupMode = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const HttpEndpointS3BackupMode = {
+    AllData: "AllData",
+    FailedDataOnly: "FailedDataOnly",
+};
+const IcebergS3BackupMode = {
+    AllData: "AllData",
+    FailedDataOnly: "FailedDataOnly",
+};
+const RedshiftS3BackupMode = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+const SnowflakeDataLoadingOption = {
+    JSON_MAPPING: "JSON_MAPPING",
+    VARIANT_CONTENT_AND_METADATA_MAPPING: "VARIANT_CONTENT_AND_METADATA_MAPPING",
+    VARIANT_CONTENT_MAPPING: "VARIANT_CONTENT_MAPPING",
+};
+const SnowflakeS3BackupMode = {
+    AllData: "AllData",
+    FailedDataOnly: "FailedDataOnly",
+};
+const HECEndpointType = {
+    Event: "Event",
+    Raw: "Raw",
+};
+const SplunkS3BackupMode = {
+    AllEvents: "AllEvents",
+    FailedEventsOnly: "FailedEventsOnly",
+};
+class InvalidArgumentException extends FirehoseServiceException {
+    name = "InvalidArgumentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArgumentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArgumentException.prototype);
+    }
+}
+class InvalidKMSResourceException extends FirehoseServiceException {
+    name = "InvalidKMSResourceException";
+    $fault = "client";
+    code;
+    constructor(opts) {
+        super({
+            name: "InvalidKMSResourceException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidKMSResourceException.prototype);
+        this.code = opts.code;
+    }
+}
+class LimitExceededException extends FirehoseServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+class ResourceInUseException extends FirehoseServiceException {
+    name = "ResourceInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceInUseException.prototype);
+    }
+}
+const DeliveryStreamFailureType = {
+    CREATE_ENI_FAILED: "CREATE_ENI_FAILED",
+    CREATE_KMS_GRANT_FAILED: "CREATE_KMS_GRANT_FAILED",
+    DELETE_ENI_FAILED: "DELETE_ENI_FAILED",
+    DISABLED_KMS_KEY: "DISABLED_KMS_KEY",
+    ENI_ACCESS_DENIED: "ENI_ACCESS_DENIED",
+    INVALID_KMS_KEY: "INVALID_KMS_KEY",
+    KMS_ACCESS_DENIED: "KMS_ACCESS_DENIED",
+    KMS_KEY_NOT_FOUND: "KMS_KEY_NOT_FOUND",
+    KMS_OPT_IN_REQUIRED: "KMS_OPT_IN_REQUIRED",
+    RETIRE_KMS_GRANT_FAILED: "RETIRE_KMS_GRANT_FAILED",
+    SECURITY_GROUP_ACCESS_DENIED: "SECURITY_GROUP_ACCESS_DENIED",
+    SECURITY_GROUP_NOT_FOUND: "SECURITY_GROUP_NOT_FOUND",
+    SUBNET_ACCESS_DENIED: "SUBNET_ACCESS_DENIED",
+    SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND",
+    UNKNOWN_ERROR: "UNKNOWN_ERROR",
+    VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND: "VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND",
+    VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED: "VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED",
+};
+const SnapshotRequestedBy = {
+    FIREHOSE: "FIREHOSE",
+    USER: "USER",
+};
+const SnapshotStatus = {
+    COMPLETE: "COMPLETE",
+    IN_PROGRESS: "IN_PROGRESS",
+    SUSPENDED: "SUSPENDED",
 };
+class ResourceNotFoundException extends FirehoseServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+const DeliveryStreamEncryptionStatus = {
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    DISABLING_FAILED: "DISABLING_FAILED",
+    ENABLED: "ENABLED",
+    ENABLING: "ENABLING",
+    ENABLING_FAILED: "ENABLING_FAILED",
+};
+const DeliveryStreamStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    CREATING_FAILED: "CREATING_FAILED",
+    DELETING: "DELETING",
+    DELETING_FAILED: "DELETING_FAILED",
+};
+class InvalidSourceException extends FirehoseServiceException {
+    name = "InvalidSourceException";
+    $fault = "client";
+    code;
+    constructor(opts) {
+        super({
+            name: "InvalidSourceException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSourceException.prototype);
+        this.code = opts.code;
+    }
+}
+class ServiceUnavailableException extends FirehoseServiceException {
+    name = "ServiceUnavailableException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "ServiceUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        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),
+    }),
+});
 
-// src/models/models_0.ts
-var ProcessorParameterName = {
-  BUFFER_INTERVAL_IN_SECONDS: "BufferIntervalInSeconds",
-  BUFFER_SIZE_IN_MB: "BufferSizeInMBs",
-  COMPRESSION_FORMAT: "CompressionFormat",
-  DATA_MESSAGE_EXTRACTION: "DataMessageExtraction",
-  Delimiter: "Delimiter",
-  JSON_PARSING_ENGINE: "JsonParsingEngine",
-  LAMBDA_ARN: "LambdaArn",
-  LAMBDA_NUMBER_OF_RETRIES: "NumberOfRetries",
-  METADATA_EXTRACTION_QUERY: "MetadataExtractionQuery",
-  ROLE_ARN: "RoleArn",
-  SUB_RECORD_TYPE: "SubRecordType"
-};
-var ProcessorType = {
-  AppendDelimiterToRecord: "AppendDelimiterToRecord",
-  CloudWatchLogProcessing: "CloudWatchLogProcessing",
-  Decompression: "Decompression",
-  Lambda: "Lambda",
-  MetadataExtraction: "MetadataExtraction",
-  RecordDeAggregation: "RecordDeAggregation"
-};
-var AmazonOpenSearchServerlessS3BackupMode = {
-  AllDocuments: "AllDocuments",
-  FailedDocumentsOnly: "FailedDocumentsOnly"
-};
-var CompressionFormat = {
-  GZIP: "GZIP",
-  HADOOP_SNAPPY: "HADOOP_SNAPPY",
-  SNAPPY: "Snappy",
-  UNCOMPRESSED: "UNCOMPRESSED",
-  ZIP: "ZIP"
-};
-var NoEncryptionConfig = {
-  NoEncryption: "NoEncryption"
-};
-var DefaultDocumentIdFormat = {
-  FIREHOSE_DEFAULT: "FIREHOSE_DEFAULT",
-  NO_DOCUMENT_ID: "NO_DOCUMENT_ID"
-};
-var AmazonopensearchserviceIndexRotationPeriod = {
-  NoRotation: "NoRotation",
-  OneDay: "OneDay",
-  OneHour: "OneHour",
-  OneMonth: "OneMonth",
-  OneWeek: "OneWeek"
-};
-var AmazonopensearchserviceS3BackupMode = {
-  AllDocuments: "AllDocuments",
-  FailedDocumentsOnly: "FailedDocumentsOnly"
-};
-var Connectivity = {
-  PRIVATE: "PRIVATE",
-  PUBLIC: "PUBLIC"
-};
-var ConcurrentModificationException = class _ConcurrentModificationException extends FirehoseServiceException {
-  static {
-    __name(this, "ConcurrentModificationException");
-  }
-  name = "ConcurrentModificationException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ConcurrentModificationException",
-      $fault: "client",
-      ...opts
+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,
     });
-    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
-  }
-};
-var ContentEncoding = {
-  GZIP: "GZIP",
-  NONE: "NONE"
-};
-var SSLMode = {
-  Disabled: "Disabled",
-  Enabled: "Enabled"
-};
-var DatabaseType = {
-  MySQL: "MySQL",
-  PostgreSQL: "PostgreSQL"
-};
-var KeyType = {
-  AWS_OWNED_CMK: "AWS_OWNED_CMK",
-  CUSTOMER_MANAGED_CMK: "CUSTOMER_MANAGED_CMK"
-};
-var DeliveryStreamType = {
-  DatabaseAsSource: "DatabaseAsSource",
-  DirectPut: "DirectPut",
-  KinesisStreamAsSource: "KinesisStreamAsSource",
-  MSKAsSource: "MSKAsSource"
-};
-var ElasticsearchIndexRotationPeriod = {
-  NoRotation: "NoRotation",
-  OneDay: "OneDay",
-  OneHour: "OneHour",
-  OneMonth: "OneMonth",
-  OneWeek: "OneWeek"
-};
-var ElasticsearchS3BackupMode = {
-  AllDocuments: "AllDocuments",
-  FailedDocumentsOnly: "FailedDocumentsOnly"
-};
-var OrcCompression = {
-  NONE: "NONE",
-  SNAPPY: "SNAPPY",
-  ZLIB: "ZLIB"
-};
-var OrcFormatVersion = {
-  V0_11: "V0_11",
-  V0_12: "V0_12"
-};
-var ParquetCompression = {
-  GZIP: "GZIP",
-  SNAPPY: "SNAPPY",
-  UNCOMPRESSED: "UNCOMPRESSED"
-};
-var ParquetWriterVersion = {
-  V1: "V1",
-  V2: "V2"
-};
-var S3BackupMode = {
-  Disabled: "Disabled",
-  Enabled: "Enabled"
-};
-var HttpEndpointS3BackupMode = {
-  AllData: "AllData",
-  FailedDataOnly: "FailedDataOnly"
-};
-var IcebergS3BackupMode = {
-  AllData: "AllData",
-  FailedDataOnly: "FailedDataOnly"
-};
-var RedshiftS3BackupMode = {
-  Disabled: "Disabled",
-  Enabled: "Enabled"
-};
-var SnowflakeDataLoadingOption = {
-  JSON_MAPPING: "JSON_MAPPING",
-  VARIANT_CONTENT_AND_METADATA_MAPPING: "VARIANT_CONTENT_AND_METADATA_MAPPING",
-  VARIANT_CONTENT_MAPPING: "VARIANT_CONTENT_MAPPING"
-};
-var SnowflakeS3BackupMode = {
-  AllData: "AllData",
-  FailedDataOnly: "FailedDataOnly"
-};
-var HECEndpointType = {
-  Event: "Event",
-  Raw: "Raw"
-};
-var SplunkS3BackupMode = {
-  AllEvents: "AllEvents",
-  FailedEventsOnly: "FailedEventsOnly"
-};
-var InvalidArgumentException = class _InvalidArgumentException extends FirehoseServiceException {
-  static {
-    __name(this, "InvalidArgumentException");
-  }
-  name = "InvalidArgumentException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidArgumentException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidArgumentException.prototype);
-  }
-};
-var InvalidKMSResourceException = class _InvalidKMSResourceException extends FirehoseServiceException {
-  static {
-    __name(this, "InvalidKMSResourceException");
-  }
-  name = "InvalidKMSResourceException";
-  $fault = "client";
-  code;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidKMSResourceException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidKMSResourceException.prototype);
-    this.code = opts.code;
-  }
-};
-var LimitExceededException = class _LimitExceededException extends FirehoseServiceException {
-  static {
-    __name(this, "LimitExceededException");
-  }
-  name = "LimitExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LimitExceededException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _LimitExceededException.prototype);
-  }
-};
-var ResourceInUseException = class _ResourceInUseException extends FirehoseServiceException {
-  static {
-    __name(this, "ResourceInUseException");
-  }
-  name = "ResourceInUseException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ResourceInUseException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
-  }
-};
-var DeliveryStreamFailureType = {
-  CREATE_ENI_FAILED: "CREATE_ENI_FAILED",
-  CREATE_KMS_GRANT_FAILED: "CREATE_KMS_GRANT_FAILED",
-  DELETE_ENI_FAILED: "DELETE_ENI_FAILED",
-  DISABLED_KMS_KEY: "DISABLED_KMS_KEY",
-  ENI_ACCESS_DENIED: "ENI_ACCESS_DENIED",
-  INVALID_KMS_KEY: "INVALID_KMS_KEY",
-  KMS_ACCESS_DENIED: "KMS_ACCESS_DENIED",
-  KMS_KEY_NOT_FOUND: "KMS_KEY_NOT_FOUND",
-  KMS_OPT_IN_REQUIRED: "KMS_OPT_IN_REQUIRED",
-  RETIRE_KMS_GRANT_FAILED: "RETIRE_KMS_GRANT_FAILED",
-  SECURITY_GROUP_ACCESS_DENIED: "SECURITY_GROUP_ACCESS_DENIED",
-  SECURITY_GROUP_NOT_FOUND: "SECURITY_GROUP_NOT_FOUND",
-  SUBNET_ACCESS_DENIED: "SUBNET_ACCESS_DENIED",
-  SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND",
-  UNKNOWN_ERROR: "UNKNOWN_ERROR",
-  VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND: "VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND",
-  VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED: "VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED"
-};
-var SnapshotRequestedBy = {
-  FIREHOSE: "FIREHOSE",
-  USER: "USER"
-};
-var SnapshotStatus = {
-  COMPLETE: "COMPLETE",
-  IN_PROGRESS: "IN_PROGRESS",
-  SUSPENDED: "SUSPENDED"
-};
-var ResourceNotFoundException = class _ResourceNotFoundException extends FirehoseServiceException {
-  static {
-    __name(this, "ResourceNotFoundException");
-  }
-  name = "ResourceNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ResourceNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
-  }
-};
-var DeliveryStreamEncryptionStatus = {
-  DISABLED: "DISABLED",
-  DISABLING: "DISABLING",
-  DISABLING_FAILED: "DISABLING_FAILED",
-  ENABLED: "ENABLED",
-  ENABLING: "ENABLING",
-  ENABLING_FAILED: "ENABLING_FAILED"
-};
-var DeliveryStreamStatus = {
-  ACTIVE: "ACTIVE",
-  CREATING: "CREATING",
-  CREATING_FAILED: "CREATING_FAILED",
-  DELETING: "DELETING",
-  DELETING_FAILED: "DELETING_FAILED"
-};
-var InvalidSourceException = class _InvalidSourceException extends FirehoseServiceException {
-  static {
-    __name(this, "InvalidSourceException");
-  }
-  name = "InvalidSourceException";
-  $fault = "client";
-  code;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidSourceException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidSourceException.prototype);
-    this.code = opts.code;
-  }
-};
-var ServiceUnavailableException = class _ServiceUnavailableException extends FirehoseServiceException {
-  static {
-    __name(this, "ServiceUnavailableException");
-  }
-  name = "ServiceUnavailableException";
-  $fault = "server";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceUnavailableException",
-      $fault: "server",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
-  }
-};
-var HttpEndpointConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Url && { Url: import_smithy_client.SENSITIVE_STRING },
-  ...obj.AccessKey && { AccessKey: import_smithy_client.SENSITIVE_STRING }
-}), "HttpEndpointConfigurationFilterSensitiveLog");
-var HttpEndpointCommonAttributeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.AttributeName && { AttributeName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.AttributeValue && { AttributeValue: import_smithy_client.SENSITIVE_STRING }
-}), "HttpEndpointCommonAttributeFilterSensitiveLog");
-var HttpEndpointRequestConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.CommonAttributes && {
-    CommonAttributes: obj.CommonAttributes.map((item) => HttpEndpointCommonAttributeFilterSensitiveLog(item))
-  }
-}), "HttpEndpointRequestConfigurationFilterSensitiveLog");
-var HttpEndpointDestinationConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.EndpointConfiguration && {
-    EndpointConfiguration: HttpEndpointConfigurationFilterSensitiveLog(obj.EndpointConfiguration)
-  },
-  ...obj.RequestConfiguration && {
-    RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration)
-  }
-}), "HttpEndpointDestinationConfigurationFilterSensitiveLog");
-var RedshiftDestinationConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Username && { Username: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
-}), "RedshiftDestinationConfigurationFilterSensitiveLog");
-var SnowflakeRoleConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.SnowflakeRole && { SnowflakeRole: import_smithy_client.SENSITIVE_STRING }
-}), "SnowflakeRoleConfigurationFilterSensitiveLog");
-var SnowflakeVpcConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.PrivateLinkVpceId && { PrivateLinkVpceId: import_smithy_client.SENSITIVE_STRING }
-}), "SnowflakeVpcConfigurationFilterSensitiveLog");
-var SnowflakeDestinationConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.AccountUrl && { AccountUrl: import_smithy_client.SENSITIVE_STRING },
-  ...obj.PrivateKey && { PrivateKey: import_smithy_client.SENSITIVE_STRING },
-  ...obj.KeyPassphrase && { KeyPassphrase: import_smithy_client.SENSITIVE_STRING },
-  ...obj.User && { User: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Database && { Database: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Schema && { Schema: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Table && { Table: import_smithy_client.SENSITIVE_STRING },
-  ...obj.SnowflakeRoleConfiguration && {
-    SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration)
-  },
-  ...obj.MetaDataColumnName && { MetaDataColumnName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.ContentColumnName && { ContentColumnName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.SnowflakeVpcConfiguration && {
-    SnowflakeVpcConfiguration: SnowflakeVpcConfigurationFilterSensitiveLog(obj.SnowflakeVpcConfiguration)
-  }
-}), "SnowflakeDestinationConfigurationFilterSensitiveLog");
-var CreateDeliveryStreamInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.RedshiftDestinationConfiguration && {
-    RedshiftDestinationConfiguration: RedshiftDestinationConfigurationFilterSensitiveLog(
-      obj.RedshiftDestinationConfiguration
-    )
-  },
-  ...obj.HttpEndpointDestinationConfiguration && {
-    HttpEndpointDestinationConfiguration: HttpEndpointDestinationConfigurationFilterSensitiveLog(
-      obj.HttpEndpointDestinationConfiguration
-    )
-  },
-  ...obj.SnowflakeDestinationConfiguration && {
-    SnowflakeDestinationConfiguration: SnowflakeDestinationConfigurationFilterSensitiveLog(
-      obj.SnowflakeDestinationConfiguration
-    )
-  }
-}), "CreateDeliveryStreamInputFilterSensitiveLog");
-var HttpEndpointDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Url && { Url: import_smithy_client.SENSITIVE_STRING }
-}), "HttpEndpointDescriptionFilterSensitiveLog");
-var HttpEndpointDestinationDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.EndpointConfiguration && {
-    EndpointConfiguration: HttpEndpointDescriptionFilterSensitiveLog(obj.EndpointConfiguration)
-  },
-  ...obj.RequestConfiguration && {
-    RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration)
-  }
-}), "HttpEndpointDestinationDescriptionFilterSensitiveLog");
-var RedshiftDestinationDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Username && { Username: import_smithy_client.SENSITIVE_STRING }
-}), "RedshiftDestinationDescriptionFilterSensitiveLog");
-var SnowflakeDestinationDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.AccountUrl && { AccountUrl: import_smithy_client.SENSITIVE_STRING },
-  ...obj.User && { User: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Database && { Database: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Schema && { Schema: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Table && { Table: import_smithy_client.SENSITIVE_STRING },
-  ...obj.SnowflakeRoleConfiguration && {
-    SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration)
-  },
-  ...obj.MetaDataColumnName && { MetaDataColumnName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.ContentColumnName && { ContentColumnName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.SnowflakeVpcConfiguration && {
-    SnowflakeVpcConfiguration: SnowflakeVpcConfigurationFilterSensitiveLog(obj.SnowflakeVpcConfiguration)
-  }
-}), "SnowflakeDestinationDescriptionFilterSensitiveLog");
-var DestinationDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.RedshiftDestinationDescription && {
-    RedshiftDestinationDescription: RedshiftDestinationDescriptionFilterSensitiveLog(
-      obj.RedshiftDestinationDescription
-    )
-  },
-  ...obj.HttpEndpointDestinationDescription && {
-    HttpEndpointDestinationDescription: HttpEndpointDestinationDescriptionFilterSensitiveLog(
-      obj.HttpEndpointDestinationDescription
-    )
-  },
-  ...obj.SnowflakeDestinationDescription && {
-    SnowflakeDestinationDescription: SnowflakeDestinationDescriptionFilterSensitiveLog(
-      obj.SnowflakeDestinationDescription
-    )
-  }
-}), "DestinationDescriptionFilterSensitiveLog");
-var DeliveryStreamDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Destinations && {
-    Destinations: obj.Destinations.map((item) => DestinationDescriptionFilterSensitiveLog(item))
-  }
-}), "DeliveryStreamDescriptionFilterSensitiveLog");
-var DescribeDeliveryStreamOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj
-}), "DescribeDeliveryStreamOutputFilterSensitiveLog");
-var HttpEndpointDestinationUpdateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.EndpointConfiguration && {
-    EndpointConfiguration: HttpEndpointConfigurationFilterSensitiveLog(obj.EndpointConfiguration)
-  },
-  ...obj.RequestConfiguration && {
-    RequestConfiguration: HttpEndpointRequestConfigurationFilterSensitiveLog(obj.RequestConfiguration)
-  }
-}), "HttpEndpointDestinationUpdateFilterSensitiveLog");
-var RedshiftDestinationUpdateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Username && { Username: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
-}), "RedshiftDestinationUpdateFilterSensitiveLog");
-var SnowflakeDestinationUpdateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.AccountUrl && { AccountUrl: import_smithy_client.SENSITIVE_STRING },
-  ...obj.PrivateKey && { PrivateKey: import_smithy_client.SENSITIVE_STRING },
-  ...obj.KeyPassphrase && { KeyPassphrase: import_smithy_client.SENSITIVE_STRING },
-  ...obj.User && { User: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Database && { Database: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Schema && { Schema: import_smithy_client.SENSITIVE_STRING },
-  ...obj.Table && { Table: import_smithy_client.SENSITIVE_STRING },
-  ...obj.SnowflakeRoleConfiguration && {
-    SnowflakeRoleConfiguration: SnowflakeRoleConfigurationFilterSensitiveLog(obj.SnowflakeRoleConfiguration)
-  },
-  ...obj.MetaDataColumnName && { MetaDataColumnName: import_smithy_client.SENSITIVE_STRING },
-  ...obj.ContentColumnName && { ContentColumnName: import_smithy_client.SENSITIVE_STRING }
-}), "SnowflakeDestinationUpdateFilterSensitiveLog");
-var UpdateDestinationInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.RedshiftDestinationUpdate && {
-    RedshiftDestinationUpdate: RedshiftDestinationUpdateFilterSensitiveLog(obj.RedshiftDestinationUpdate)
-  },
-  ...obj.HttpEndpointDestinationUpdate && {
-    HttpEndpointDestinationUpdate: HttpEndpointDestinationUpdateFilterSensitiveLog(obj.HttpEndpointDestinationUpdate)
-  },
-  ...obj.SnowflakeDestinationUpdate && {
-    SnowflakeDestinationUpdate: SnowflakeDestinationUpdateFilterSensitiveLog(obj.SnowflakeDestinationUpdate)
-  }
-}), "UpdateDestinationInputFilterSensitiveLog");
-
-// src/protocols/Aws_json1_1.ts
-var import_core2 = require("@aws-sdk/core");
-
-
-var se_CreateDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CreateDeliveryStream");
-  let body;
-  body = JSON.stringify(se_CreateDeliveryStreamInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CreateDeliveryStreamCommand");
-var se_DeleteDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteDeliveryStream");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteDeliveryStreamCommand");
-var se_DescribeDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeDeliveryStream");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeDeliveryStreamCommand");
-var se_ListDeliveryStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListDeliveryStreams");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListDeliveryStreamsCommand");
-var se_ListTagsForDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListTagsForDeliveryStream");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListTagsForDeliveryStreamCommand");
-var se_PutRecordCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PutRecord");
-  let body;
-  body = JSON.stringify(se_PutRecordInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PutRecordCommand");
-var se_PutRecordBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PutRecordBatch");
-  let body;
-  body = JSON.stringify(se_PutRecordBatchInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PutRecordBatchCommand");
-var se_StartDeliveryStreamEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("StartDeliveryStreamEncryption");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_StartDeliveryStreamEncryptionCommand");
-var se_StopDeliveryStreamEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("StopDeliveryStreamEncryption");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_StopDeliveryStreamEncryptionCommand");
-var se_TagDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("TagDeliveryStream");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_TagDeliveryStreamCommand");
-var se_UntagDeliveryStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UntagDeliveryStream");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UntagDeliveryStreamCommand");
-var se_UpdateDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UpdateDestination");
-  let body;
-  body = JSON.stringify(se_UpdateDestinationInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UpdateDestinationCommand");
-var de_CreateDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateDeliveryStreamCommand");
-var de_DeleteDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteDeliveryStreamCommand");
-var de_DescribeDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeDeliveryStreamOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeDeliveryStreamCommand");
-var de_ListDeliveryStreamsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListDeliveryStreamsCommand");
-var de_ListTagsForDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListTagsForDeliveryStreamCommand");
-var de_PutRecordCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PutRecordCommand");
-var de_PutRecordBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PutRecordBatchCommand");
-var de_StartDeliveryStreamEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_StartDeliveryStreamEncryptionCommand");
-var de_StopDeliveryStreamEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_StopDeliveryStreamEncryptionCommand");
-var de_TagDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_TagDeliveryStreamCommand");
-var de_UntagDeliveryStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UntagDeliveryStreamCommand");
-var de_UpdateDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateDestinationCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
-  switch (errorCode) {
-    case "InvalidArgumentException":
-    case "com.amazonaws.firehose#InvalidArgumentException":
-      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
-    case "InvalidKMSResourceException":
-    case "com.amazonaws.firehose#InvalidKMSResourceException":
-      throw await de_InvalidKMSResourceExceptionRes(parsedOutput, context);
-    case "LimitExceededException":
-    case "com.amazonaws.firehose#LimitExceededException":
-      throw await de_LimitExceededExceptionRes(parsedOutput, context);
-    case "ResourceInUseException":
-    case "com.amazonaws.firehose#ResourceInUseException":
-      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
-    case "ResourceNotFoundException":
-    case "com.amazonaws.firehose#ResourceNotFoundException":
-      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-    case "InvalidSourceException":
-    case "com.amazonaws.firehose#InvalidSourceException":
-      throw await de_InvalidSourceExceptionRes(parsedOutput, context);
-    case "ServiceUnavailableException":
-    case "com.amazonaws.firehose#ServiceUnavailableException":
-      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
-    case "ConcurrentModificationException":
-    case "com.amazonaws.firehose#ConcurrentModificationException":
-      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
-    default:
-      const parsedBody = parsedOutput.body;
-      return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode
-      });
-  }
-}, "de_CommandError");
-var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ConcurrentModificationException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ConcurrentModificationExceptionRes");
-var de_InvalidArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidArgumentException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidArgumentExceptionRes");
-var de_InvalidKMSResourceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidKMSResourceException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidKMSResourceExceptionRes");
-var de_InvalidSourceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidSourceException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidSourceExceptionRes");
-var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LimitExceededException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LimitExceededExceptionRes");
-var de_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ResourceInUseException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ResourceInUseExceptionRes");
-var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ResourceNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ResourceNotFoundExceptionRes");
-var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ServiceUnavailableException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ServiceUnavailableExceptionRes");
-var se_CreateDeliveryStreamInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    AmazonOpenSearchServerlessDestinationConfiguration: import_smithy_client._json,
-    AmazonopensearchserviceDestinationConfiguration: import_smithy_client._json,
-    DatabaseSourceConfiguration: import_smithy_client._json,
-    DeliveryStreamEncryptionConfigurationInput: import_smithy_client._json,
-    DeliveryStreamName: [],
-    DeliveryStreamType: [],
-    DirectPutSourceConfiguration: import_smithy_client._json,
-    ElasticsearchDestinationConfiguration: import_smithy_client._json,
-    ExtendedS3DestinationConfiguration: /* @__PURE__ */ __name((_) => se_ExtendedS3DestinationConfiguration(_, context), "ExtendedS3DestinationConfiguration"),
-    HttpEndpointDestinationConfiguration: import_smithy_client._json,
-    IcebergDestinationConfiguration: import_smithy_client._json,
-    KinesisStreamSourceConfiguration: import_smithy_client._json,
-    MSKSourceConfiguration: /* @__PURE__ */ __name((_) => se_MSKSourceConfiguration(_, context), "MSKSourceConfiguration"),
-    RedshiftDestinationConfiguration: import_smithy_client._json,
-    S3DestinationConfiguration: import_smithy_client._json,
-    SnowflakeDestinationConfiguration: import_smithy_client._json,
-    SplunkDestinationConfiguration: import_smithy_client._json,
-    Tags: import_smithy_client._json
-  });
-}, "se_CreateDeliveryStreamInput");
-var se_DataFormatConversionConfiguration = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    Enabled: [],
-    InputFormatConfiguration: import_smithy_client._json,
-    OutputFormatConfiguration: /* @__PURE__ */ __name((_) => se_OutputFormatConfiguration(_, context), "OutputFormatConfiguration"),
-    SchemaConfiguration: import_smithy_client._json
-  });
-}, "se_DataFormatConversionConfiguration");
-var se_ExtendedS3DestinationConfiguration = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    BucketARN: [],
-    BufferingHints: import_smithy_client._json,
-    CloudWatchLoggingOptions: import_smithy_client._json,
-    CompressionFormat: [],
-    CustomTimeZone: [],
-    DataFormatConversionConfiguration: /* @__PURE__ */ __name((_) => se_DataFormatConversionConfiguration(_, context), "DataFormatConversionConfiguration"),
-    DynamicPartitioningConfiguration: import_smithy_client._json,
-    EncryptionConfiguration: import_smithy_client._json,
-    ErrorOutputPrefix: [],
-    FileExtension: [],
-    Prefix: [],
-    ProcessingConfiguration: import_smithy_client._json,
-    RoleARN: [],
-    S3BackupConfiguration: import_smithy_client._json,
-    S3BackupMode: []
-  });
-}, "se_ExtendedS3DestinationConfiguration");
-var se_ExtendedS3DestinationUpdate = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    BucketARN: [],
-    BufferingHints: import_smithy_client._json,
-    CloudWatchLoggingOptions: import_smithy_client._json,
-    CompressionFormat: [],
-    CustomTimeZone: [],
-    DataFormatConversionConfiguration: /* @__PURE__ */ __name((_) => se_DataFormatConversionConfiguration(_, context), "DataFormatConversionConfiguration"),
-    DynamicPartitioningConfiguration: import_smithy_client._json,
-    EncryptionConfiguration: import_smithy_client._json,
-    ErrorOutputPrefix: [],
-    FileExtension: [],
-    Prefix: [],
-    ProcessingConfiguration: import_smithy_client._json,
-    RoleARN: [],
-    S3BackupMode: [],
-    S3BackupUpdate: import_smithy_client._json
-  });
-}, "se_ExtendedS3DestinationUpdate");
-var se_MSKSourceConfiguration = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    AuthenticationConfiguration: import_smithy_client._json,
-    MSKClusterARN: [],
-    ReadFromTimestamp: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "ReadFromTimestamp"),
-    TopicName: []
-  });
-}, "se_MSKSourceConfiguration");
-var se_OrcSerDe = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    BlockSizeBytes: [],
-    BloomFilterColumns: import_smithy_client._json,
-    BloomFilterFalsePositiveProbability: import_smithy_client.serializeFloat,
-    Compression: [],
-    DictionaryKeyThreshold: import_smithy_client.serializeFloat,
-    EnablePadding: [],
-    FormatVersion: [],
-    PaddingTolerance: import_smithy_client.serializeFloat,
-    RowIndexStride: [],
-    StripeSizeBytes: []
-  });
-}, "se_OrcSerDe");
-var se_OutputFormatConfiguration = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    Serializer: /* @__PURE__ */ __name((_) => se_Serializer(_, context), "Serializer")
-  });
-}, "se_OutputFormatConfiguration");
-var se_PutRecordBatchInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    DeliveryStreamName: [],
-    Records: /* @__PURE__ */ __name((_) => se_PutRecordBatchRequestEntryList(_, context), "Records")
-  });
-}, "se_PutRecordBatchInput");
-var se_PutRecordBatchRequestEntryList = /* @__PURE__ */ __name((input, context) => {
-  return input.filter((e) => e != null).map((entry) => {
-    return se__Record(entry, context);
-  });
-}, "se_PutRecordBatchRequestEntryList");
-var se_PutRecordInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    DeliveryStreamName: [],
-    Record: /* @__PURE__ */ __name((_) => se__Record(_, context), "Record")
-  });
-}, "se_PutRecordInput");
-var se__Record = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    Data: context.base64Encoder
-  });
-}, "se__Record");
-var se_Serializer = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    OrcSerDe: /* @__PURE__ */ __name((_) => se_OrcSerDe(_, context), "OrcSerDe"),
-    ParquetSerDe: import_smithy_client._json
-  });
-}, "se_Serializer");
-var se_UpdateDestinationInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    AmazonOpenSearchServerlessDestinationUpdate: import_smithy_client._json,
-    AmazonopensearchserviceDestinationUpdate: import_smithy_client._json,
-    CurrentDeliveryStreamVersionId: [],
-    DeliveryStreamName: [],
-    DestinationId: [],
-    ElasticsearchDestinationUpdate: import_smithy_client._json,
-    ExtendedS3DestinationUpdate: /* @__PURE__ */ __name((_) => se_ExtendedS3DestinationUpdate(_, context), "ExtendedS3DestinationUpdate"),
-    HttpEndpointDestinationUpdate: import_smithy_client._json,
-    IcebergDestinationUpdate: import_smithy_client._json,
-    RedshiftDestinationUpdate: import_smithy_client._json,
-    S3DestinationUpdate: import_smithy_client._json,
-    SnowflakeDestinationUpdate: import_smithy_client._json,
-    SplunkDestinationUpdate: import_smithy_client._json
-  });
-}, "se_UpdateDestinationInput");
-var de_DatabaseSnapshotInfo = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    FailureDescription: import_smithy_client._json,
-    Id: import_smithy_client.expectString,
-    RequestTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "RequestTimestamp"),
-    RequestedBy: import_smithy_client.expectString,
-    Status: import_smithy_client.expectString,
-    Table: import_smithy_client.expectString
-  });
-}, "de_DatabaseSnapshotInfo");
-var de_DatabaseSnapshotInfoList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_DatabaseSnapshotInfo(entry, context);
-  });
-  return retVal;
-}, "de_DatabaseSnapshotInfoList");
-var de_DatabaseSourceDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Columns: import_smithy_client._json,
-    DatabaseSourceAuthenticationConfiguration: import_smithy_client._json,
-    DatabaseSourceVPCConfiguration: import_smithy_client._json,
-    Databases: import_smithy_client._json,
-    Endpoint: import_smithy_client.expectString,
-    Port: import_smithy_client.expectInt32,
-    SSLMode: import_smithy_client.expectString,
-    SnapshotInfo: /* @__PURE__ */ __name((_) => de_DatabaseSnapshotInfoList(_, context), "SnapshotInfo"),
-    SnapshotWatermarkTable: import_smithy_client.expectString,
-    SurrogateKeys: import_smithy_client._json,
-    Tables: import_smithy_client._json,
-    Type: import_smithy_client.expectString
-  });
-}, "de_DatabaseSourceDescription");
-var de_DataFormatConversionConfiguration = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Enabled: import_smithy_client.expectBoolean,
-    InputFormatConfiguration: import_smithy_client._json,
-    OutputFormatConfiguration: /* @__PURE__ */ __name((_) => de_OutputFormatConfiguration(_, context), "OutputFormatConfiguration"),
-    SchemaConfiguration: import_smithy_client._json
-  });
-}, "de_DataFormatConversionConfiguration");
-var de_DeliveryStreamDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    CreateTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreateTimestamp"),
-    DeliveryStreamARN: import_smithy_client.expectString,
-    DeliveryStreamEncryptionConfiguration: import_smithy_client._json,
-    DeliveryStreamName: import_smithy_client.expectString,
-    DeliveryStreamStatus: import_smithy_client.expectString,
-    DeliveryStreamType: import_smithy_client.expectString,
-    Destinations: /* @__PURE__ */ __name((_) => de_DestinationDescriptionList(_, context), "Destinations"),
-    FailureDescription: import_smithy_client._json,
-    HasMoreDestinations: import_smithy_client.expectBoolean,
-    LastUpdateTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastUpdateTimestamp"),
-    Source: /* @__PURE__ */ __name((_) => de_SourceDescription(_, context), "Source"),
-    VersionId: import_smithy_client.expectString
-  });
-}, "de_DeliveryStreamDescription");
-var de_DescribeDeliveryStreamOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    DeliveryStreamDescription: /* @__PURE__ */ __name((_) => de_DeliveryStreamDescription(_, context), "DeliveryStreamDescription")
-  });
-}, "de_DescribeDeliveryStreamOutput");
-var de_DestinationDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    AmazonOpenSearchServerlessDestinationDescription: import_smithy_client._json,
-    AmazonopensearchserviceDestinationDescription: import_smithy_client._json,
-    DestinationId: import_smithy_client.expectString,
-    ElasticsearchDestinationDescription: import_smithy_client._json,
-    ExtendedS3DestinationDescription: /* @__PURE__ */ __name((_) => de_ExtendedS3DestinationDescription(_, context), "ExtendedS3DestinationDescription"),
-    HttpEndpointDestinationDescription: import_smithy_client._json,
-    IcebergDestinationDescription: import_smithy_client._json,
-    RedshiftDestinationDescription: import_smithy_client._json,
-    S3DestinationDescription: import_smithy_client._json,
-    SnowflakeDestinationDescription: import_smithy_client._json,
-    SplunkDestinationDescription: import_smithy_client._json
-  });
-}, "de_DestinationDescription");
-var de_DestinationDescriptionList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_DestinationDescription(entry, context);
-  });
-  return retVal;
-}, "de_DestinationDescriptionList");
-var de_ExtendedS3DestinationDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    BucketARN: import_smithy_client.expectString,
-    BufferingHints: import_smithy_client._json,
-    CloudWatchLoggingOptions: import_smithy_client._json,
-    CompressionFormat: import_smithy_client.expectString,
-    CustomTimeZone: import_smithy_client.expectString,
-    DataFormatConversionConfiguration: /* @__PURE__ */ __name((_) => de_DataFormatConversionConfiguration(_, context), "DataFormatConversionConfiguration"),
-    DynamicPartitioningConfiguration: import_smithy_client._json,
-    EncryptionConfiguration: import_smithy_client._json,
-    ErrorOutputPrefix: import_smithy_client.expectString,
-    FileExtension: import_smithy_client.expectString,
-    Prefix: import_smithy_client.expectString,
-    ProcessingConfiguration: import_smithy_client._json,
-    RoleARN: import_smithy_client.expectString,
-    S3BackupDescription: import_smithy_client._json,
-    S3BackupMode: import_smithy_client.expectString
-  });
-}, "de_ExtendedS3DestinationDescription");
-var de_KinesisStreamSourceDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    DeliveryStartTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "DeliveryStartTimestamp"),
-    KinesisStreamARN: import_smithy_client.expectString,
-    RoleARN: import_smithy_client.expectString
-  });
-}, "de_KinesisStreamSourceDescription");
-var de_MSKSourceDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    AuthenticationConfiguration: import_smithy_client._json,
-    DeliveryStartTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "DeliveryStartTimestamp"),
-    MSKClusterARN: import_smithy_client.expectString,
-    ReadFromTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "ReadFromTimestamp"),
-    TopicName: import_smithy_client.expectString
-  });
-}, "de_MSKSourceDescription");
-var de_OrcSerDe = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    BlockSizeBytes: import_smithy_client.expectInt32,
-    BloomFilterColumns: import_smithy_client._json,
-    BloomFilterFalsePositiveProbability: import_smithy_client.limitedParseDouble,
-    Compression: import_smithy_client.expectString,
-    DictionaryKeyThreshold: import_smithy_client.limitedParseDouble,
-    EnablePadding: import_smithy_client.expectBoolean,
-    FormatVersion: import_smithy_client.expectString,
-    PaddingTolerance: import_smithy_client.limitedParseDouble,
-    RowIndexStride: import_smithy_client.expectInt32,
-    StripeSizeBytes: import_smithy_client.expectInt32
-  });
-}, "de_OrcSerDe");
-var de_OutputFormatConfiguration = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Serializer: /* @__PURE__ */ __name((_) => de_Serializer(_, context), "Serializer")
-  });
-}, "de_OutputFormatConfiguration");
-var de_Serializer = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    OrcSerDe: /* @__PURE__ */ __name((_) => de_OrcSerDe(_, context), "OrcSerDe"),
-    ParquetSerDe: import_smithy_client._json
-  });
-}, "de_Serializer");
-var de_SourceDescription = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    DatabaseSourceDescription: /* @__PURE__ */ __name((_) => de_DatabaseSourceDescription(_, context), "DatabaseSourceDescription"),
-    DirectPutSourceDescription: import_smithy_client._json,
-    KinesisStreamSourceDescription: /* @__PURE__ */ __name((_) => de_KinesisStreamSourceDescription(_, context), "KinesisStreamSourceDescription"),
-    MSKSourceDescription: /* @__PURE__ */ __name((_) => de_MSKSourceDescription(_, context), "MSKSourceDescription")
-  });
-}, "de_SourceDescription");
-var deserializeMetadata = /* @__PURE__ */ __name((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"]
-}), "deserializeMetadata");
-var throwDefaultError = (0, import_smithy_client.withBaseException)(FirehoseServiceException);
-var buildHttpRpcRequest = /* @__PURE__ */ __name(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 (resolvedHostname !== void 0) {
-    contents.hostname = resolvedHostname;
-  }
-  if (body !== void 0) {
-    contents.body = body;
-  }
-  return new import_protocol_http.HttpRequest(contents);
-}, "buildHttpRpcRequest");
-function sharedHeaders(operation) {
-  return {
-    "content-type": "application/x-amz-json-1.1",
-    "x-amz-target": `Firehose_20150804.${operation}`
-  };
-}
-__name(sharedHeaders, "sharedHeaders");
-
-// src/commands/CreateDeliveryStreamCommand.ts
-var CreateDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "CreateDeliveryStream", {}).n("FirehoseClient", "CreateDeliveryStreamCommand").f(CreateDeliveryStreamInputFilterSensitiveLog, void 0).ser(se_CreateDeliveryStreamCommand).de(de_CreateDeliveryStreamCommand).build() {
-  static {
-    __name(this, "CreateDeliveryStreamCommand");
-  }
+    return smithyClient.decorateServiceException(exception, body);
 };
-
-// src/commands/DeleteDeliveryStreamCommand.ts
-
-
-
-var DeleteDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "DeleteDeliveryStream", {}).n("FirehoseClient", "DeleteDeliveryStreamCommand").f(void 0, void 0).ser(se_DeleteDeliveryStreamCommand).de(de_DeleteDeliveryStreamCommand).build() {
-  static {
-    __name(this, "DeleteDeliveryStreamCommand");
-  }
+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,
+    });
 };
-
-// src/commands/DescribeDeliveryStreamCommand.ts
-
-
-
-var DescribeDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "DescribeDeliveryStream", {}).n("FirehoseClient", "DescribeDeliveryStreamCommand").f(void 0, DescribeDeliveryStreamOutputFilterSensitiveLog).ser(se_DescribeDeliveryStreamCommand).de(de_DescribeDeliveryStreamCommand).build() {
-  static {
-    __name(this, "DescribeDeliveryStreamCommand");
-  }
+const se_DataFormatConversionConfiguration = (input, context) => {
+    return smithyClient.take(input, {
+        Enabled: [],
+        InputFormatConfiguration: smithyClient._json,
+        OutputFormatConfiguration: (_) => se_OutputFormatConfiguration(_),
+        SchemaConfiguration: smithyClient._json,
+    });
 };
-
-// src/commands/ListDeliveryStreamsCommand.ts
-
-
-
-var ListDeliveryStreamsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "ListDeliveryStreams", {}).n("FirehoseClient", "ListDeliveryStreamsCommand").f(void 0, void 0).ser(se_ListDeliveryStreamsCommand).de(de_ListDeliveryStreamsCommand).build() {
-  static {
-    __name(this, "ListDeliveryStreamsCommand");
-  }
+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: [],
+    });
 };
-
-// src/commands/ListTagsForDeliveryStreamCommand.ts
-
-
-
-var ListTagsForDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "ListTagsForDeliveryStream", {}).n("FirehoseClient", "ListTagsForDeliveryStreamCommand").f(void 0, void 0).ser(se_ListTagsForDeliveryStreamCommand).de(de_ListTagsForDeliveryStreamCommand).build() {
-  static {
-    __name(this, "ListTagsForDeliveryStreamCommand");
-  }
+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,
+    });
 };
-
-// src/commands/PutRecordBatchCommand.ts
-
-
-
-var PutRecordBatchCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "PutRecordBatch", {}).n("FirehoseClient", "PutRecordBatchCommand").f(void 0, void 0).ser(se_PutRecordBatchCommand).de(de_PutRecordBatchCommand).build() {
-  static {
-    __name(this, "PutRecordBatchCommand");
-  }
+const se_MSKSourceConfiguration = (input, context) => {
+    return smithyClient.take(input, {
+        AuthenticationConfiguration: smithyClient._json,
+        MSKClusterARN: [],
+        ReadFromTimestamp: (_) => _.getTime() / 1_000,
+        TopicName: [],
+    });
 };
-
-// src/commands/PutRecordCommand.ts
-
-
-
-var PutRecordCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "PutRecord", {}).n("FirehoseClient", "PutRecordCommand").f(void 0, void 0).ser(se_PutRecordCommand).de(de_PutRecordCommand).build() {
-  static {
-    __name(this, "PutRecordCommand");
-  }
+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: [],
+    });
 };
-
-// src/commands/StartDeliveryStreamEncryptionCommand.ts
-
-
-
-var StartDeliveryStreamEncryptionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "StartDeliveryStreamEncryption", {}).n("FirehoseClient", "StartDeliveryStreamEncryptionCommand").f(void 0, void 0).ser(se_StartDeliveryStreamEncryptionCommand).de(de_StartDeliveryStreamEncryptionCommand).build() {
-  static {
-    __name(this, "StartDeliveryStreamEncryptionCommand");
-  }
+const se_OutputFormatConfiguration = (input, context) => {
+    return smithyClient.take(input, {
+        Serializer: (_) => se_Serializer(_),
+    });
 };
-
-// src/commands/StopDeliveryStreamEncryptionCommand.ts
-
-
-
-var StopDeliveryStreamEncryptionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "StopDeliveryStreamEncryption", {}).n("FirehoseClient", "StopDeliveryStreamEncryptionCommand").f(void 0, void 0).ser(se_StopDeliveryStreamEncryptionCommand).de(de_StopDeliveryStreamEncryptionCommand).build() {
-  static {
-    __name(this, "StopDeliveryStreamEncryptionCommand");
-  }
+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}`,
+    };
+}
 
-// src/commands/TagDeliveryStreamCommand.ts
+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()),
+    ];
+})
+    .s("Firehose_20150804", "CreateDeliveryStream", {})
+    .n("FirehoseClient", "CreateDeliveryStreamCommand")
+    .f(CreateDeliveryStreamInputFilterSensitiveLog, void 0)
+    .ser(se_CreateDeliveryStreamCommand)
+    .de(de_CreateDeliveryStreamCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "DeleteDeliveryStream", {})
+    .n("FirehoseClient", "DeleteDeliveryStreamCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteDeliveryStreamCommand)
+    .de(de_DeleteDeliveryStreamCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "DescribeDeliveryStream", {})
+    .n("FirehoseClient", "DescribeDeliveryStreamCommand")
+    .f(void 0, DescribeDeliveryStreamOutputFilterSensitiveLog)
+    .ser(se_DescribeDeliveryStreamCommand)
+    .de(de_DescribeDeliveryStreamCommand)
+    .build() {
+}
 
-var TagDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "TagDeliveryStream", {}).n("FirehoseClient", "TagDeliveryStreamCommand").f(void 0, void 0).ser(se_TagDeliveryStreamCommand).de(de_TagDeliveryStreamCommand).build() {
-  static {
-    __name(this, "TagDeliveryStreamCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("Firehose_20150804", "ListDeliveryStreams", {})
+    .n("FirehoseClient", "ListDeliveryStreamsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListDeliveryStreamsCommand)
+    .de(de_ListDeliveryStreamsCommand)
+    .build() {
+}
 
-// src/commands/UntagDeliveryStreamCommand.ts
+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()),
+    ];
+})
+    .s("Firehose_20150804", "ListTagsForDeliveryStream", {})
+    .n("FirehoseClient", "ListTagsForDeliveryStreamCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsForDeliveryStreamCommand)
+    .de(de_ListTagsForDeliveryStreamCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "PutRecordBatch", {})
+    .n("FirehoseClient", "PutRecordBatchCommand")
+    .f(void 0, void 0)
+    .ser(se_PutRecordBatchCommand)
+    .de(de_PutRecordBatchCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "PutRecord", {})
+    .n("FirehoseClient", "PutRecordCommand")
+    .f(void 0, void 0)
+    .ser(se_PutRecordCommand)
+    .de(de_PutRecordCommand)
+    .build() {
+}
 
-var UntagDeliveryStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "UntagDeliveryStream", {}).n("FirehoseClient", "UntagDeliveryStreamCommand").f(void 0, void 0).ser(se_UntagDeliveryStreamCommand).de(de_UntagDeliveryStreamCommand).build() {
-  static {
-    __name(this, "UntagDeliveryStreamCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("Firehose_20150804", "StartDeliveryStreamEncryption", {})
+    .n("FirehoseClient", "StartDeliveryStreamEncryptionCommand")
+    .f(void 0, void 0)
+    .ser(se_StartDeliveryStreamEncryptionCommand)
+    .de(de_StartDeliveryStreamEncryptionCommand)
+    .build() {
+}
 
-// src/commands/UpdateDestinationCommand.ts
+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()),
+    ];
+})
+    .s("Firehose_20150804", "StopDeliveryStreamEncryption", {})
+    .n("FirehoseClient", "StopDeliveryStreamEncryptionCommand")
+    .f(void 0, void 0)
+    .ser(se_StopDeliveryStreamEncryptionCommand)
+    .de(de_StopDeliveryStreamEncryptionCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "TagDeliveryStream", {})
+    .n("FirehoseClient", "TagDeliveryStreamCommand")
+    .f(void 0, void 0)
+    .ser(se_TagDeliveryStreamCommand)
+    .de(de_TagDeliveryStreamCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("Firehose_20150804", "UntagDeliveryStream", {})
+    .n("FirehoseClient", "UntagDeliveryStreamCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagDeliveryStreamCommand)
+    .de(de_UntagDeliveryStreamCommand)
+    .build() {
+}
 
-var UpdateDestinationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("Firehose_20150804", "UpdateDestination", {}).n("FirehoseClient", "UpdateDestinationCommand").f(UpdateDestinationInputFilterSensitiveLog, void 0).ser(se_UpdateDestinationCommand).de(de_UpdateDestinationCommand).build() {
-  static {
-    __name(this, "UpdateDestinationCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("Firehose_20150804", "UpdateDestination", {})
+    .n("FirehoseClient", "UpdateDestinationCommand")
+    .f(UpdateDestinationInputFilterSensitiveLog, void 0)
+    .ser(se_UpdateDestinationCommand)
+    .de(de_UpdateDestinationCommand)
+    .build() {
+}
 
-// src/Firehose.ts
-var commands = {
-  CreateDeliveryStreamCommand,
-  DeleteDeliveryStreamCommand,
-  DescribeDeliveryStreamCommand,
-  ListDeliveryStreamsCommand,
-  ListTagsForDeliveryStreamCommand,
-  PutRecordCommand,
-  PutRecordBatchCommand,
-  StartDeliveryStreamEncryptionCommand,
-  StopDeliveryStreamEncryptionCommand,
-  TagDeliveryStreamCommand,
-  UntagDeliveryStreamCommand,
-  UpdateDestinationCommand
-};
-var Firehose = class extends FirehoseClient {
-  static {
-    __name(this, "Firehose");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, Firehose);
-// Annotate the CommonJS export names for ESM import in node:
+const commands = {
+    CreateDeliveryStreamCommand,
+    DeleteDeliveryStreamCommand,
+    DescribeDeliveryStreamCommand,
+    ListDeliveryStreamsCommand,
+    ListTagsForDeliveryStreamCommand,
+    PutRecordCommand,
+    PutRecordBatchCommand,
+    StartDeliveryStreamEncryptionCommand,
+    StopDeliveryStreamEncryptionCommand,
+    TagDeliveryStreamCommand,
+    UntagDeliveryStreamCommand,
+    UpdateDestinationCommand,
+};
+class Firehose extends FirehoseClient {
+}
+smithyClient.createAggregatedClient(commands, Firehose);
 
-0 && (module.exports = {
-  FirehoseServiceException,
-  __Client,
-  FirehoseClient,
-  Firehose,
-  $Command,
-  CreateDeliveryStreamCommand,
-  DeleteDeliveryStreamCommand,
-  DescribeDeliveryStreamCommand,
-  ListDeliveryStreamsCommand,
-  ListTagsForDeliveryStreamCommand,
-  PutRecordBatchCommand,
-  PutRecordCommand,
-  StartDeliveryStreamEncryptionCommand,
-  StopDeliveryStreamEncryptionCommand,
-  TagDeliveryStreamCommand,
-  UntagDeliveryStreamCommand,
-  UpdateDestinationCommand,
-  ProcessorParameterName,
-  ProcessorType,
-  AmazonOpenSearchServerlessS3BackupMode,
-  CompressionFormat,
-  NoEncryptionConfig,
-  DefaultDocumentIdFormat,
-  AmazonopensearchserviceIndexRotationPeriod,
-  AmazonopensearchserviceS3BackupMode,
-  Connectivity,
-  ConcurrentModificationException,
-  ContentEncoding,
-  SSLMode,
-  DatabaseType,
-  KeyType,
-  DeliveryStreamType,
-  ElasticsearchIndexRotationPeriod,
-  ElasticsearchS3BackupMode,
-  OrcCompression,
-  OrcFormatVersion,
-  ParquetCompression,
-  ParquetWriterVersion,
-  S3BackupMode,
-  HttpEndpointS3BackupMode,
-  IcebergS3BackupMode,
-  RedshiftS3BackupMode,
-  SnowflakeDataLoadingOption,
-  SnowflakeS3BackupMode,
-  HECEndpointType,
-  SplunkS3BackupMode,
-  InvalidArgumentException,
-  InvalidKMSResourceException,
-  LimitExceededException,
-  ResourceInUseException,
-  DeliveryStreamFailureType,
-  SnapshotRequestedBy,
-  SnapshotStatus,
-  ResourceNotFoundException,
-  DeliveryStreamEncryptionStatus,
-  DeliveryStreamStatus,
-  InvalidSourceException,
-  ServiceUnavailableException,
-  HttpEndpointConfigurationFilterSensitiveLog,
-  HttpEndpointCommonAttributeFilterSensitiveLog,
-  HttpEndpointRequestConfigurationFilterSensitiveLog,
-  HttpEndpointDestinationConfigurationFilterSensitiveLog,
-  RedshiftDestinationConfigurationFilterSensitiveLog,
-  SnowflakeRoleConfigurationFilterSensitiveLog,
-  SnowflakeVpcConfigurationFilterSensitiveLog,
-  SnowflakeDestinationConfigurationFilterSensitiveLog,
-  CreateDeliveryStreamInputFilterSensitiveLog,
-  HttpEndpointDescriptionFilterSensitiveLog,
-  HttpEndpointDestinationDescriptionFilterSensitiveLog,
-  RedshiftDestinationDescriptionFilterSensitiveLog,
-  SnowflakeDestinationDescriptionFilterSensitiveLog,
-  DestinationDescriptionFilterSensitiveLog,
-  DeliveryStreamDescriptionFilterSensitiveLog,
-  DescribeDeliveryStreamOutputFilterSensitiveLog,
-  HttpEndpointDestinationUpdateFilterSensitiveLog,
-  RedshiftDestinationUpdateFilterSensitiveLog,
-  SnowflakeDestinationUpdateFilterSensitiveLog,
-  UpdateDestinationInputFilterSensitiveLog
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
-
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.AmazonOpenSearchServerlessS3BackupMode = AmazonOpenSearchServerlessS3BackupMode;
+exports.AmazonopensearchserviceIndexRotationPeriod = AmazonopensearchserviceIndexRotationPeriod;
+exports.AmazonopensearchserviceS3BackupMode = AmazonopensearchserviceS3BackupMode;
+exports.CompressionFormat = CompressionFormat;
+exports.ConcurrentModificationException = ConcurrentModificationException;
+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.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.KeyType = KeyType;
+exports.LimitExceededException = LimitExceededException;
+exports.ListDeliveryStreamsCommand = ListDeliveryStreamsCommand;
+exports.ListTagsForDeliveryStreamCommand = ListTagsForDeliveryStreamCommand;
+exports.NoEncryptionConfig = NoEncryptionConfig;
+exports.OrcCompression = OrcCompression;
+exports.OrcFormatVersion = OrcFormatVersion;
+exports.ParquetCompression = ParquetCompression;
+exports.ParquetWriterVersion = ParquetWriterVersion;
+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.S3BackupMode = S3BackupMode;
+exports.SSLMode = SSLMode;
+exports.ServiceUnavailableException = ServiceUnavailableException;
+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;