@aws-sdk/client-pipes 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,1804 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PipesServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./PipesClient"), exports);
-tslib_1.__exportStar(require("./Pipes"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var PipesServiceException_1 = require("./models/PipesServiceException");
-Object.defineProperty(exports, "PipesServiceException", { enumerable: true, get: function () { return PipesServiceException_1.PipesServiceException; } });
+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 src_exports = {};
+__export(src_exports, {
+  AssignPublicIp: () => AssignPublicIp,
+  AwsVpcConfigurationFilterSensitiveLog: () => AwsVpcConfigurationFilterSensitiveLog,
+  BatchJobDependencyType: () => BatchJobDependencyType,
+  BatchResourceRequirementType: () => BatchResourceRequirementType,
+  CapacityProviderStrategyItemFilterSensitiveLog: () => CapacityProviderStrategyItemFilterSensitiveLog,
+  ConflictException: () => ConflictException,
+  CreatePipeCommand: () => CreatePipeCommand,
+  CreatePipeRequestFilterSensitiveLog: () => CreatePipeRequestFilterSensitiveLog,
+  DeletePipeCommand: () => DeletePipeCommand,
+  DescribePipeCommand: () => DescribePipeCommand,
+  DescribePipeResponseFilterSensitiveLog: () => DescribePipeResponseFilterSensitiveLog,
+  DynamoDBStreamStartPosition: () => DynamoDBStreamStartPosition,
+  EcsEnvironmentFileType: () => EcsEnvironmentFileType,
+  EcsResourceRequirementType: () => EcsResourceRequirementType,
+  FilterCriteriaFilterSensitiveLog: () => FilterCriteriaFilterSensitiveLog,
+  FilterFilterSensitiveLog: () => FilterFilterSensitiveLog,
+  IncludeExecutionDataOption: () => IncludeExecutionDataOption,
+  InternalException: () => InternalException,
+  KinesisStreamStartPosition: () => KinesisStreamStartPosition,
+  LaunchType: () => LaunchType,
+  ListPipesCommand: () => ListPipesCommand,
+  ListPipesRequestFilterSensitiveLog: () => ListPipesRequestFilterSensitiveLog,
+  ListPipesResponseFilterSensitiveLog: () => ListPipesResponseFilterSensitiveLog,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTagsForResourceResponseFilterSensitiveLog: () => ListTagsForResourceResponseFilterSensitiveLog,
+  LogLevel: () => LogLevel,
+  MQBrokerAccessCredentials: () => MQBrokerAccessCredentials,
+  MSKAccessCredentials: () => MSKAccessCredentials,
+  MSKStartPosition: () => MSKStartPosition,
+  NetworkConfigurationFilterSensitiveLog: () => NetworkConfigurationFilterSensitiveLog,
+  NotFoundException: () => NotFoundException,
+  OnPartialBatchItemFailureStreams: () => OnPartialBatchItemFailureStreams,
+  PipeEnrichmentHttpParametersFilterSensitiveLog: () => PipeEnrichmentHttpParametersFilterSensitiveLog,
+  PipeEnrichmentParametersFilterSensitiveLog: () => PipeEnrichmentParametersFilterSensitiveLog,
+  PipeSourceActiveMQBrokerParametersFilterSensitiveLog: () => PipeSourceActiveMQBrokerParametersFilterSensitiveLog,
+  PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog: () => PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog,
+  PipeSourceParametersFilterSensitiveLog: () => PipeSourceParametersFilterSensitiveLog,
+  PipeSourceRabbitMQBrokerParametersFilterSensitiveLog: () => PipeSourceRabbitMQBrokerParametersFilterSensitiveLog,
+  PipeSourceSelfManagedKafkaParametersFilterSensitiveLog: () => PipeSourceSelfManagedKafkaParametersFilterSensitiveLog,
+  PipeState: () => PipeState,
+  PipeTargetEcsTaskParametersFilterSensitiveLog: () => PipeTargetEcsTaskParametersFilterSensitiveLog,
+  PipeTargetEventBridgeEventBusParametersFilterSensitiveLog: () => PipeTargetEventBridgeEventBusParametersFilterSensitiveLog,
+  PipeTargetHttpParametersFilterSensitiveLog: () => PipeTargetHttpParametersFilterSensitiveLog,
+  PipeTargetInvocationType: () => PipeTargetInvocationType,
+  PipeTargetKinesisStreamParametersFilterSensitiveLog: () => PipeTargetKinesisStreamParametersFilterSensitiveLog,
+  PipeTargetParametersFilterSensitiveLog: () => PipeTargetParametersFilterSensitiveLog,
+  PipeTargetRedshiftDataParametersFilterSensitiveLog: () => PipeTargetRedshiftDataParametersFilterSensitiveLog,
+  PipeTargetSageMakerPipelineParametersFilterSensitiveLog: () => PipeTargetSageMakerPipelineParametersFilterSensitiveLog,
+  PipeTargetSqsQueueParametersFilterSensitiveLog: () => PipeTargetSqsQueueParametersFilterSensitiveLog,
+  Pipes: () => Pipes,
+  PipesClient: () => PipesClient,
+  PipesServiceException: () => PipesServiceException,
+  PlacementConstraintFilterSensitiveLog: () => PlacementConstraintFilterSensitiveLog,
+  PlacementConstraintType: () => PlacementConstraintType,
+  PlacementStrategyFilterSensitiveLog: () => PlacementStrategyFilterSensitiveLog,
+  PlacementStrategyType: () => PlacementStrategyType,
+  PropagateTags: () => PropagateTags,
+  RequestedPipeState: () => RequestedPipeState,
+  RequestedPipeStateDescribeResponse: () => RequestedPipeStateDescribeResponse,
+  S3OutputFormat: () => S3OutputFormat,
+  SageMakerPipelineParameterFilterSensitiveLog: () => SageMakerPipelineParameterFilterSensitiveLog,
+  SelfManagedKafkaAccessConfigurationCredentials: () => SelfManagedKafkaAccessConfigurationCredentials,
+  SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog: () => SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog,
+  SelfManagedKafkaStartPosition: () => SelfManagedKafkaStartPosition,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartPipeCommand: () => StartPipeCommand,
+  StopPipeCommand: () => StopPipeCommand,
+  TagFilterSensitiveLog: () => TagFilterSensitiveLog,
+  TagResourceCommand: () => TagResourceCommand,
+  TagResourceRequestFilterSensitiveLog: () => TagResourceRequestFilterSensitiveLog,
+  ThrottlingException: () => ThrottlingException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdatePipeCommand: () => UpdatePipeCommand,
+  UpdatePipeRequestFilterSensitiveLog: () => UpdatePipeRequestFilterSensitiveLog,
+  UpdatePipeSourceParametersFilterSensitiveLog: () => UpdatePipeSourceParametersFilterSensitiveLog,
+  UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog: () => UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateListPipes: () => paginateListPipes
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PipesClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "pipes"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/PipesClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// 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");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/PipesClient.ts
+var _PipesClient = class _PipesClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_PipesClient, "PipesClient");
+var PipesClient = _PipesClient;
+
+// src/Pipes.ts
+
+
+// src/commands/CreatePipeCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/models/models_0.ts
+
+
+// src/models/PipesServiceException.ts
+
+var _PipesServiceException = class _PipesServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _PipesServiceException.prototype);
+  }
+};
+__name(_PipesServiceException, "PipesServiceException");
+var PipesServiceException = _PipesServiceException;
+
+// src/models/models_0.ts
+var AssignPublicIp = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var BatchResourceRequirementType = {
+  GPU: "GPU",
+  MEMORY: "MEMORY",
+  VCPU: "VCPU"
+};
+var BatchJobDependencyType = {
+  N_TO_N: "N_TO_N",
+  SEQUENTIAL: "SEQUENTIAL"
+};
+var _ConflictException = class _ConflictException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var RequestedPipeState = {
+  RUNNING: "RUNNING",
+  STOPPED: "STOPPED"
+};
+var IncludeExecutionDataOption = {
+  ALL: "ALL"
+};
+var LogLevel = {
+  ERROR: "ERROR",
+  INFO: "INFO",
+  OFF: "OFF",
+  TRACE: "TRACE"
+};
+var S3OutputFormat = {
+  JSON: "json",
+  PLAIN: "plain",
+  W3C: "w3c"
+};
+var MQBrokerAccessCredentials;
+((MQBrokerAccessCredentials3) => {
+  MQBrokerAccessCredentials3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.BasicAuth !== void 0)
+      return visitor.BasicAuth(value.BasicAuth);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(MQBrokerAccessCredentials || (MQBrokerAccessCredentials = {}));
+var OnPartialBatchItemFailureStreams = {
+  AUTOMATIC_BISECT: "AUTOMATIC_BISECT"
+};
+var DynamoDBStreamStartPosition = {
+  LATEST: "LATEST",
+  TRIM_HORIZON: "TRIM_HORIZON"
+};
+var KinesisStreamStartPosition = {
+  AT_TIMESTAMP: "AT_TIMESTAMP",
+  LATEST: "LATEST",
+  TRIM_HORIZON: "TRIM_HORIZON"
+};
+var MSKAccessCredentials;
+((MSKAccessCredentials3) => {
+  MSKAccessCredentials3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.SaslScram512Auth !== void 0)
+      return visitor.SaslScram512Auth(value.SaslScram512Auth);
+    if (value.ClientCertificateTlsAuth !== void 0)
+      return visitor.ClientCertificateTlsAuth(value.ClientCertificateTlsAuth);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(MSKAccessCredentials || (MSKAccessCredentials = {}));
+var MSKStartPosition = {
+  LATEST: "LATEST",
+  TRIM_HORIZON: "TRIM_HORIZON"
+};
+var SelfManagedKafkaAccessConfigurationCredentials;
+((SelfManagedKafkaAccessConfigurationCredentials3) => {
+  SelfManagedKafkaAccessConfigurationCredentials3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.BasicAuth !== void 0)
+      return visitor.BasicAuth(value.BasicAuth);
+    if (value.SaslScram512Auth !== void 0)
+      return visitor.SaslScram512Auth(value.SaslScram512Auth);
+    if (value.SaslScram256Auth !== void 0)
+      return visitor.SaslScram256Auth(value.SaslScram256Auth);
+    if (value.ClientCertificateTlsAuth !== void 0)
+      return visitor.ClientCertificateTlsAuth(value.ClientCertificateTlsAuth);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(SelfManagedKafkaAccessConfigurationCredentials || (SelfManagedKafkaAccessConfigurationCredentials = {}));
+var SelfManagedKafkaStartPosition = {
+  LATEST: "LATEST",
+  TRIM_HORIZON: "TRIM_HORIZON"
+};
+var LaunchType = {
+  EC2: "EC2",
+  EXTERNAL: "EXTERNAL",
+  FARGATE: "FARGATE"
+};
+var EcsEnvironmentFileType = {
+  s3: "s3"
+};
+var EcsResourceRequirementType = {
+  GPU: "GPU",
+  InferenceAccelerator: "InferenceAccelerator"
+};
+var PlacementConstraintType = {
+  DISTINCT_INSTANCE: "distinctInstance",
+  MEMBER_OF: "memberOf"
+};
+var PlacementStrategyType = {
+  BINPACK: "binpack",
+  RANDOM: "random",
+  SPREAD: "spread"
+};
+var PropagateTags = {
+  TASK_DEFINITION: "TASK_DEFINITION"
+};
+var PipeTargetInvocationType = {
+  FIRE_AND_FORGET: "FIRE_AND_FORGET",
+  REQUEST_RESPONSE: "REQUEST_RESPONSE"
+};
+var PipeState = {
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATE_ROLLBACK_FAILED: "CREATE_ROLLBACK_FAILED",
+  CREATING: "CREATING",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETE_ROLLBACK_FAILED: "DELETE_ROLLBACK_FAILED",
+  DELETING: "DELETING",
+  RUNNING: "RUNNING",
+  STARTING: "STARTING",
+  START_FAILED: "START_FAILED",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING",
+  STOP_FAILED: "STOP_FAILED",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
+  UPDATING: "UPDATING"
+};
+var _InternalException = class _InternalException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalException.prototype);
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_InternalException, "InternalException");
+var InternalException = _InternalException;
+var _NotFoundException = class _NotFoundException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ThrottlingException = class _ThrottlingException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends PipesServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.fieldList = opts.fieldList;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var RequestedPipeStateDescribeResponse = {
+  DELETED: "DELETED",
+  RUNNING: "RUNNING",
+  STOPPED: "STOPPED"
+};
+var AwsVpcConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Subnets && { Subnets: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SecurityGroups && { SecurityGroups: import_smithy_client.SENSITIVE_STRING }
+}), "AwsVpcConfigurationFilterSensitiveLog");
+var CapacityProviderStrategyItemFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.capacityProvider && { capacityProvider: import_smithy_client.SENSITIVE_STRING }
+}), "CapacityProviderStrategyItemFilterSensitiveLog");
+var PipeEnrichmentHttpParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PathParameterValues && { PathParameterValues: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HeaderParameters && { HeaderParameters: import_smithy_client.SENSITIVE_STRING },
+  ...obj.QueryStringParameters && { QueryStringParameters: import_smithy_client.SENSITIVE_STRING }
+}), "PipeEnrichmentHttpParametersFilterSensitiveLog");
+var PipeEnrichmentParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputTemplate && { InputTemplate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HttpParameters && { HttpParameters: PipeEnrichmentHttpParametersFilterSensitiveLog(obj.HttpParameters) }
+}), "PipeEnrichmentParametersFilterSensitiveLog");
+var PipeSourceActiveMQBrokerParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Credentials && { Credentials: obj.Credentials },
+  ...obj.QueueName && { QueueName: import_smithy_client.SENSITIVE_STRING }
+}), "PipeSourceActiveMQBrokerParametersFilterSensitiveLog");
+var FilterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Pattern && { Pattern: import_smithy_client.SENSITIVE_STRING }
+}), "FilterFilterSensitiveLog");
+var FilterCriteriaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Filters && { Filters: obj.Filters.map((item) => FilterFilterSensitiveLog(item)) }
+}), "FilterCriteriaFilterSensitiveLog");
+var PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TopicName && { TopicName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ConsumerGroupID && { ConsumerGroupID: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Credentials && { Credentials: obj.Credentials }
+}), "PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog");
+var PipeSourceRabbitMQBrokerParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Credentials && { Credentials: obj.Credentials },
+  ...obj.QueueName && { QueueName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.VirtualHost && { VirtualHost: import_smithy_client.SENSITIVE_STRING }
+}), "PipeSourceRabbitMQBrokerParametersFilterSensitiveLog");
+var SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Subnets && { Subnets: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SecurityGroup && { SecurityGroup: import_smithy_client.SENSITIVE_STRING }
+}), "SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog");
+var PipeSourceSelfManagedKafkaParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TopicName && { TopicName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AdditionalBootstrapServers && { AdditionalBootstrapServers: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ConsumerGroupID && { ConsumerGroupID: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Credentials && { Credentials: obj.Credentials },
+  ...obj.Vpc && { Vpc: SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog(obj.Vpc) }
+}), "PipeSourceSelfManagedKafkaParametersFilterSensitiveLog");
+var PipeSourceParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FilterCriteria && { FilterCriteria: FilterCriteriaFilterSensitiveLog(obj.FilterCriteria) },
+  ...obj.ActiveMQBrokerParameters && {
+    ActiveMQBrokerParameters: PipeSourceActiveMQBrokerParametersFilterSensitiveLog(obj.ActiveMQBrokerParameters)
+  },
+  ...obj.RabbitMQBrokerParameters && {
+    RabbitMQBrokerParameters: PipeSourceRabbitMQBrokerParametersFilterSensitiveLog(obj.RabbitMQBrokerParameters)
+  },
+  ...obj.ManagedStreamingKafkaParameters && {
+    ManagedStreamingKafkaParameters: PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog(
+      obj.ManagedStreamingKafkaParameters
+    )
+  },
+  ...obj.SelfManagedKafkaParameters && {
+    SelfManagedKafkaParameters: PipeSourceSelfManagedKafkaParametersFilterSensitiveLog(obj.SelfManagedKafkaParameters)
+  }
+}), "PipeSourceParametersFilterSensitiveLog");
+var NetworkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.awsvpcConfiguration && {
+    awsvpcConfiguration: AwsVpcConfigurationFilterSensitiveLog(obj.awsvpcConfiguration)
+  }
+}), "NetworkConfigurationFilterSensitiveLog");
+var PlacementConstraintFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.expression && { expression: import_smithy_client.SENSITIVE_STRING }
+}), "PlacementConstraintFilterSensitiveLog");
+var PlacementStrategyFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.field && { field: import_smithy_client.SENSITIVE_STRING }
+}), "PlacementStrategyFilterSensitiveLog");
+var TagFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "TagFilterSensitiveLog");
+var PipeTargetEcsTaskParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NetworkConfiguration && {
+    NetworkConfiguration: NetworkConfigurationFilterSensitiveLog(obj.NetworkConfiguration)
+  },
+  ...obj.CapacityProviderStrategy && {
+    CapacityProviderStrategy: obj.CapacityProviderStrategy.map(
+      (item) => CapacityProviderStrategyItemFilterSensitiveLog(item)
+    )
+  },
+  ...obj.PlacementConstraints && {
+    PlacementConstraints: obj.PlacementConstraints.map((item) => PlacementConstraintFilterSensitiveLog(item))
+  },
+  ...obj.PlacementStrategy && {
+    PlacementStrategy: obj.PlacementStrategy.map((item) => PlacementStrategyFilterSensitiveLog(item))
+  },
+  ...obj.ReferenceId && { ReferenceId: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }
+}), "PipeTargetEcsTaskParametersFilterSensitiveLog");
+var PipeTargetEventBridgeEventBusParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EndpointId && { EndpointId: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DetailType && { DetailType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Source && { Source: import_smithy_client.SENSITIVE_STRING }
+}), "PipeTargetEventBridgeEventBusParametersFilterSensitiveLog");
+var PipeTargetHttpParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PathParameterValues && { PathParameterValues: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HeaderParameters && { HeaderParameters: import_smithy_client.SENSITIVE_STRING },
+  ...obj.QueryStringParameters && { QueryStringParameters: import_smithy_client.SENSITIVE_STRING }
+}), "PipeTargetHttpParametersFilterSensitiveLog");
+var PipeTargetKinesisStreamParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PartitionKey && { PartitionKey: import_smithy_client.SENSITIVE_STRING }
+}), "PipeTargetKinesisStreamParametersFilterSensitiveLog");
+var PipeTargetRedshiftDataParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Database && { Database: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DbUser && { DbUser: import_smithy_client.SENSITIVE_STRING },
+  ...obj.StatementName && { StatementName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Sqls && { Sqls: import_smithy_client.SENSITIVE_STRING }
+}), "PipeTargetRedshiftDataParametersFilterSensitiveLog");
+var SageMakerPipelineParameterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "SageMakerPipelineParameterFilterSensitiveLog");
+var PipeTargetSageMakerPipelineParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PipelineParameterList && {
+    PipelineParameterList: obj.PipelineParameterList.map((item) => SageMakerPipelineParameterFilterSensitiveLog(item))
+  }
+}), "PipeTargetSageMakerPipelineParametersFilterSensitiveLog");
+var PipeTargetSqsQueueParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MessageGroupId && { MessageGroupId: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MessageDeduplicationId && { MessageDeduplicationId: import_smithy_client.SENSITIVE_STRING }
+}), "PipeTargetSqsQueueParametersFilterSensitiveLog");
+var PipeTargetParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputTemplate && { InputTemplate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KinesisStreamParameters && {
+    KinesisStreamParameters: PipeTargetKinesisStreamParametersFilterSensitiveLog(obj.KinesisStreamParameters)
+  },
+  ...obj.EcsTaskParameters && {
+    EcsTaskParameters: PipeTargetEcsTaskParametersFilterSensitiveLog(obj.EcsTaskParameters)
+  },
+  ...obj.SqsQueueParameters && {
+    SqsQueueParameters: PipeTargetSqsQueueParametersFilterSensitiveLog(obj.SqsQueueParameters)
+  },
+  ...obj.HttpParameters && { HttpParameters: PipeTargetHttpParametersFilterSensitiveLog(obj.HttpParameters) },
+  ...obj.RedshiftDataParameters && {
+    RedshiftDataParameters: PipeTargetRedshiftDataParametersFilterSensitiveLog(obj.RedshiftDataParameters)
+  },
+  ...obj.SageMakerPipelineParameters && {
+    SageMakerPipelineParameters: PipeTargetSageMakerPipelineParametersFilterSensitiveLog(
+      obj.SageMakerPipelineParameters
+    )
+  },
+  ...obj.EventBridgeEventBusParameters && {
+    EventBridgeEventBusParameters: PipeTargetEventBridgeEventBusParametersFilterSensitiveLog(
+      obj.EventBridgeEventBusParameters
+    )
+  }
+}), "PipeTargetParametersFilterSensitiveLog");
+var CreatePipeRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Description && { Description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SourceParameters && { SourceParameters: PipeSourceParametersFilterSensitiveLog(obj.SourceParameters) },
+  ...obj.EnrichmentParameters && {
+    EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters)
+  },
+  ...obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) },
+  ...obj.Tags && { Tags: import_smithy_client.SENSITIVE_STRING }
+}), "CreatePipeRequestFilterSensitiveLog");
+var DescribePipeResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Description && { Description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SourceParameters && { SourceParameters: PipeSourceParametersFilterSensitiveLog(obj.SourceParameters) },
+  ...obj.EnrichmentParameters && {
+    EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters)
+  },
+  ...obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) },
+  ...obj.Tags && { Tags: import_smithy_client.SENSITIVE_STRING }
+}), "DescribePipeResponseFilterSensitiveLog");
+var ListPipesRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListPipesRequestFilterSensitiveLog");
+var ListPipesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListPipesResponseFilterSensitiveLog");
+var ListTagsForResourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
+}), "ListTagsForResourceResponseFilterSensitiveLog");
+var UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Credentials && { Credentials: obj.Credentials },
+  ...obj.Vpc && { Vpc: SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog(obj.Vpc) }
+}), "UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog");
+var UpdatePipeSourceParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FilterCriteria && { FilterCriteria: FilterCriteriaFilterSensitiveLog(obj.FilterCriteria) },
+  ...obj.ActiveMQBrokerParameters && { ActiveMQBrokerParameters: obj.ActiveMQBrokerParameters },
+  ...obj.RabbitMQBrokerParameters && { RabbitMQBrokerParameters: obj.RabbitMQBrokerParameters },
+  ...obj.ManagedStreamingKafkaParameters && { ManagedStreamingKafkaParameters: obj.ManagedStreamingKafkaParameters },
+  ...obj.SelfManagedKafkaParameters && {
+    SelfManagedKafkaParameters: UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog(
+      obj.SelfManagedKafkaParameters
+    )
+  }
+}), "UpdatePipeSourceParametersFilterSensitiveLog");
+var UpdatePipeRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Description && { Description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SourceParameters && { SourceParameters: UpdatePipeSourceParametersFilterSensitiveLog(obj.SourceParameters) },
+  ...obj.EnrichmentParameters && {
+    EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters)
+  },
+  ...obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) }
+}), "UpdatePipeRequestFilterSensitiveLog");
+var TagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.tags && { tags: import_smithy_client.SENSITIVE_STRING }
+}), "TagResourceRequestFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var se_CreatePipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/pipes/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Description: [],
+      DesiredState: [],
+      Enrichment: [],
+      EnrichmentParameters: (_) => (0, import_smithy_client._json)(_),
+      LogConfiguration: (_) => (0, import_smithy_client._json)(_),
+      RoleArn: [],
+      Source: [],
+      SourceParameters: (_) => se_PipeSourceParameters(_, context),
+      Tags: (_) => (0, import_smithy_client._json)(_),
+      Target: [],
+      TargetParameters: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreatePipeCommand");
+var se_DeletePipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/pipes/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeletePipeCommand");
+var se_DescribePipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/pipes/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribePipeCommand");
+var se_ListPipesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/pipes");
+  const query = (0, import_smithy_client.map)({
+    [_NP]: [, input[_NP]],
+    [_DS]: [, input[_DS]],
+    [_CS]: [, input[_CS]],
+    [_SP]: [, input[_SP]],
+    [_TP]: [, input[_TP]],
+    [_NT]: [, input[_NT]],
+    [_L]: [() => input.Limit !== void 0, () => input[_L].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListPipesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_StartPipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/pipes/{Name}/start");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartPipeCommand");
+var se_StopPipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/pipes/{Name}/stop");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopPipeCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdatePipeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/pipes/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Description: [],
+      DesiredState: [],
+      Enrichment: [],
+      EnrichmentParameters: (_) => (0, import_smithy_client._json)(_),
+      LogConfiguration: (_) => (0, import_smithy_client._json)(_),
+      RoleArn: [],
+      SourceParameters: (_) => (0, import_smithy_client._json)(_),
+      Target: [],
+      TargetParameters: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdatePipeCommand");
+var de_CreatePipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreatePipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreatePipeCommand");
+var de_CreatePipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.pipes#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.pipes#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePipeCommandError");
+var de_DeletePipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeletePipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeletePipeCommand");
+var de_DeletePipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.pipes#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePipeCommandError");
+var de_DescribePipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribePipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    Enrichment: import_smithy_client.expectString,
+    EnrichmentParameters: import_smithy_client._json,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LogConfiguration: import_smithy_client._json,
+    Name: import_smithy_client.expectString,
+    RoleArn: import_smithy_client.expectString,
+    Source: import_smithy_client.expectString,
+    SourceParameters: (_) => de_PipeSourceParameters(_, context),
+    StateReason: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    Target: import_smithy_client.expectString,
+    TargetParameters: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribePipeCommand");
+var de_DescribePipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribePipeCommandError");
+var de_ListPipesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListPipesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Pipes: (_) => de_PipeList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPipesCommand");
+var de_ListPipesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPipesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartPipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartPipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartPipeCommand");
+var de_StartPipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.pipes#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartPipeCommandError");
+var de_StopPipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopPipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StopPipeCommand");
+var de_StopPipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.pipes#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopPipeCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdatePipeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdatePipeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdatePipeCommand");
+var de_UpdatePipeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.pipes#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.pipes#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.pipes#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.pipes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.pipes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdatePipeCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(PipesServiceException);
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    quotaCode: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    quotaCode: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    fieldList: import_smithy_client._json,
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_PipeSourceKinesisStreamParameters = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BatchSize: [],
+    DeadLetterConfig: import_smithy_client._json,
+    MaximumBatchingWindowInSeconds: [],
+    MaximumRecordAgeInSeconds: [],
+    MaximumRetryAttempts: [],
+    OnPartialBatchItemFailure: [],
+    ParallelizationFactor: [],
+    StartingPosition: [],
+    StartingPositionTimestamp: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_PipeSourceKinesisStreamParameters");
+var se_PipeSourceParameters = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    ActiveMQBrokerParameters: import_smithy_client._json,
+    DynamoDBStreamParameters: import_smithy_client._json,
+    FilterCriteria: import_smithy_client._json,
+    KinesisStreamParameters: (_) => se_PipeSourceKinesisStreamParameters(_, context),
+    ManagedStreamingKafkaParameters: import_smithy_client._json,
+    RabbitMQBrokerParameters: import_smithy_client._json,
+    SelfManagedKafkaParameters: import_smithy_client._json,
+    SqsQueueParameters: import_smithy_client._json
+  });
+}, "se_PipeSourceParameters");
+var de_Pipe = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CurrentState: import_smithy_client.expectString,
+    DesiredState: import_smithy_client.expectString,
+    Enrichment: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString,
+    Source: import_smithy_client.expectString,
+    StateReason: import_smithy_client.expectString,
+    Target: import_smithy_client.expectString
+  });
+}, "de_Pipe");
+var de_PipeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Pipe(entry, context);
+  });
+  return retVal;
+}, "de_PipeList");
+var de_PipeSourceKinesisStreamParameters = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BatchSize: import_smithy_client.expectInt32,
+    DeadLetterConfig: import_smithy_client._json,
+    MaximumBatchingWindowInSeconds: import_smithy_client.expectInt32,
+    MaximumRecordAgeInSeconds: import_smithy_client.expectInt32,
+    MaximumRetryAttempts: import_smithy_client.expectInt32,
+    OnPartialBatchItemFailure: import_smithy_client.expectString,
+    ParallelizationFactor: import_smithy_client.expectInt32,
+    StartingPosition: import_smithy_client.expectString,
+    StartingPositionTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_PipeSourceKinesisStreamParameters");
+var de_PipeSourceParameters = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ActiveMQBrokerParameters: import_smithy_client._json,
+    DynamoDBStreamParameters: import_smithy_client._json,
+    FilterCriteria: import_smithy_client._json,
+    KinesisStreamParameters: (_) => de_PipeSourceKinesisStreamParameters(_, context),
+    ManagedStreamingKafkaParameters: import_smithy_client._json,
+    RabbitMQBrokerParameters: import_smithy_client._json,
+    SelfManagedKafkaParameters: import_smithy_client._json,
+    SqsQueueParameters: import_smithy_client._json
+  });
+}, "de_PipeSourceParameters");
+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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _CS = "CurrentState";
+var _DS = "DesiredState";
+var _L = "Limit";
+var _NP = "NamePrefix";
+var _NT = "NextToken";
+var _SP = "SourcePrefix";
+var _TP = "TargetPrefix";
+var _rAS = "retryAfterSeconds";
+var _ra = "retry-after";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreatePipeCommand.ts
+var _CreatePipeCommand = class _CreatePipeCommand 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("Pipes", "CreatePipe", {}).n("PipesClient", "CreatePipeCommand").f(CreatePipeRequestFilterSensitiveLog, void 0).ser(se_CreatePipeCommand).de(de_CreatePipeCommand).build() {
+};
+__name(_CreatePipeCommand, "CreatePipeCommand");
+var CreatePipeCommand = _CreatePipeCommand;
+
+// src/commands/DeletePipeCommand.ts
+
+
+
+
+var _DeletePipeCommand = class _DeletePipeCommand 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("Pipes", "DeletePipe", {}).n("PipesClient", "DeletePipeCommand").f(void 0, void 0).ser(se_DeletePipeCommand).de(de_DeletePipeCommand).build() {
+};
+__name(_DeletePipeCommand, "DeletePipeCommand");
+var DeletePipeCommand = _DeletePipeCommand;
+
+// src/commands/DescribePipeCommand.ts
+
+
+
+
+var _DescribePipeCommand = class _DescribePipeCommand 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("Pipes", "DescribePipe", {}).n("PipesClient", "DescribePipeCommand").f(void 0, DescribePipeResponseFilterSensitiveLog).ser(se_DescribePipeCommand).de(de_DescribePipeCommand).build() {
+};
+__name(_DescribePipeCommand, "DescribePipeCommand");
+var DescribePipeCommand = _DescribePipeCommand;
+
+// src/commands/ListPipesCommand.ts
+
+
+
+
+var _ListPipesCommand = class _ListPipesCommand 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("Pipes", "ListPipes", {}).n("PipesClient", "ListPipesCommand").f(ListPipesRequestFilterSensitiveLog, ListPipesResponseFilterSensitiveLog).ser(se_ListPipesCommand).de(de_ListPipesCommand).build() {
+};
+__name(_ListPipesCommand, "ListPipesCommand");
+var ListPipesCommand = _ListPipesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("Pipes", "ListTagsForResource", {}).n("PipesClient", "ListTagsForResourceCommand").f(void 0, ListTagsForResourceResponseFilterSensitiveLog).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartPipeCommand.ts
+
+
+
+
+var _StartPipeCommand = class _StartPipeCommand 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("Pipes", "StartPipe", {}).n("PipesClient", "StartPipeCommand").f(void 0, void 0).ser(se_StartPipeCommand).de(de_StartPipeCommand).build() {
+};
+__name(_StartPipeCommand, "StartPipeCommand");
+var StartPipeCommand = _StartPipeCommand;
+
+// src/commands/StopPipeCommand.ts
+
+
+
+
+var _StopPipeCommand = class _StopPipeCommand 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("Pipes", "StopPipe", {}).n("PipesClient", "StopPipeCommand").f(void 0, void 0).ser(se_StopPipeCommand).de(de_StopPipeCommand).build() {
+};
+__name(_StopPipeCommand, "StopPipeCommand");
+var StopPipeCommand = _StopPipeCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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("Pipes", "TagResource", {}).n("PipesClient", "TagResourceCommand").f(TagResourceRequestFilterSensitiveLog, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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("Pipes", "UntagResource", {}).n("PipesClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdatePipeCommand.ts
+
+
+
+
+var _UpdatePipeCommand = class _UpdatePipeCommand 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("Pipes", "UpdatePipe", {}).n("PipesClient", "UpdatePipeCommand").f(UpdatePipeRequestFilterSensitiveLog, void 0).ser(se_UpdatePipeCommand).de(de_UpdatePipeCommand).build() {
+};
+__name(_UpdatePipeCommand, "UpdatePipeCommand");
+var UpdatePipeCommand = _UpdatePipeCommand;
+
+// src/Pipes.ts
+var commands = {
+  CreatePipeCommand,
+  DeletePipeCommand,
+  DescribePipeCommand,
+  ListPipesCommand,
+  ListTagsForResourceCommand,
+  StartPipeCommand,
+  StopPipeCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdatePipeCommand
+};
+var _Pipes = class _Pipes extends PipesClient {
+};
+__name(_Pipes, "Pipes");
+var Pipes = _Pipes;
+(0, import_smithy_client.createAggregatedClient)(commands, Pipes);
+
+// src/pagination/ListPipesPaginator.ts
+
+var paginateListPipes = (0, import_core.createPaginator)(PipesClient, ListPipesCommand, "NextToken", "NextToken", "Limit");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssignPublicIp,
+  AwsVpcConfigurationFilterSensitiveLog,
+  BatchJobDependencyType,
+  BatchResourceRequirementType,
+  CapacityProviderStrategyItemFilterSensitiveLog,
+  ConflictException,
+  CreatePipeCommand,
+  CreatePipeRequestFilterSensitiveLog,
+  DeletePipeCommand,
+  DescribePipeCommand,
+  DescribePipeResponseFilterSensitiveLog,
+  DynamoDBStreamStartPosition,
+  EcsEnvironmentFileType,
+  EcsResourceRequirementType,
+  FilterCriteriaFilterSensitiveLog,
+  FilterFilterSensitiveLog,
+  IncludeExecutionDataOption,
+  InternalException,
+  KinesisStreamStartPosition,
+  LaunchType,
+  ListPipesCommand,
+  ListPipesRequestFilterSensitiveLog,
+  ListPipesResponseFilterSensitiveLog,
+  ListTagsForResourceCommand,
+  ListTagsForResourceResponseFilterSensitiveLog,
+  LogLevel,
+  MQBrokerAccessCredentials,
+  MSKAccessCredentials,
+  MSKStartPosition,
+  NetworkConfigurationFilterSensitiveLog,
+  NotFoundException,
+  OnPartialBatchItemFailureStreams,
+  PipeEnrichmentHttpParametersFilterSensitiveLog,
+  PipeEnrichmentParametersFilterSensitiveLog,
+  PipeSourceActiveMQBrokerParametersFilterSensitiveLog,
+  PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog,
+  PipeSourceParametersFilterSensitiveLog,
+  PipeSourceRabbitMQBrokerParametersFilterSensitiveLog,
+  PipeSourceSelfManagedKafkaParametersFilterSensitiveLog,
+  PipeState,
+  PipeTargetEcsTaskParametersFilterSensitiveLog,
+  PipeTargetEventBridgeEventBusParametersFilterSensitiveLog,
+  PipeTargetHttpParametersFilterSensitiveLog,
+  PipeTargetInvocationType,
+  PipeTargetKinesisStreamParametersFilterSensitiveLog,
+  PipeTargetParametersFilterSensitiveLog,
+  PipeTargetRedshiftDataParametersFilterSensitiveLog,
+  PipeTargetSageMakerPipelineParametersFilterSensitiveLog,
+  PipeTargetSqsQueueParametersFilterSensitiveLog,
+  Pipes,
+  PipesClient,
+  PipesServiceException,
+  PlacementConstraintFilterSensitiveLog,
+  PlacementConstraintType,
+  PlacementStrategyFilterSensitiveLog,
+  PlacementStrategyType,
+  PropagateTags,
+  RequestedPipeState,
+  RequestedPipeStateDescribeResponse,
+  S3OutputFormat,
+  SageMakerPipelineParameterFilterSensitiveLog,
+  SelfManagedKafkaAccessConfigurationCredentials,
+  SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog,
+  SelfManagedKafkaStartPosition,
+  ServiceQuotaExceededException,
+  StartPipeCommand,
+  StopPipeCommand,
+  TagFilterSensitiveLog,
+  TagResourceCommand,
+  TagResourceRequestFilterSensitiveLog,
+  ThrottlingException,
+  UntagResourceCommand,
+  UpdatePipeCommand,
+  UpdatePipeRequestFilterSensitiveLog,
+  UpdatePipeSourceParametersFilterSensitiveLog,
+  UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog,
+  ValidationException,
+  __Client,
+  paginateListPipes
+});