@aws-sdk/client-pipes 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class PipesClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class PipesClient extends smithyClient.Client {
     }
 }
 
-class PipesServiceException extends smithyClient.ServiceException {
+let PipesServiceException$1 = class PipesServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, PipesServiceException.prototype);
     }
-}
+};
 
 const AssignPublicIp = {
     DISABLED: "DISABLED",
@@ -130,7 +130,7 @@ const BatchJobDependencyType = {
     N_TO_N: "N_TO_N",
     SEQUENTIAL: "SEQUENTIAL",
 };
-class ConflictException extends PipesServiceException {
+let ConflictException$1 = class ConflictException extends PipesServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     resourceId;
@@ -145,7 +145,7 @@ class ConflictException extends PipesServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
+};
 const RequestedPipeState = {
     RUNNING: "RUNNING",
     STOPPED: "STOPPED",
@@ -164,14 +164,6 @@ const S3OutputFormat = {
     PLAIN: "plain",
     W3C: "w3c",
 };
-exports.MQBrokerAccessCredentials = void 0;
-(function (MQBrokerAccessCredentials) {
-    MQBrokerAccessCredentials.visit = (value, visitor) => {
-        if (value.BasicAuth !== undefined)
-            return visitor.BasicAuth(value.BasicAuth);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.MQBrokerAccessCredentials || (exports.MQBrokerAccessCredentials = {}));
 const OnPartialBatchItemFailureStreams = {
     AUTOMATIC_BISECT: "AUTOMATIC_BISECT",
 };
@@ -184,34 +176,10 @@ const KinesisStreamStartPosition = {
     LATEST: "LATEST",
     TRIM_HORIZON: "TRIM_HORIZON",
 };
-exports.MSKAccessCredentials = void 0;
-(function (MSKAccessCredentials) {
-    MSKAccessCredentials.visit = (value, visitor) => {
-        if (value.SaslScram512Auth !== undefined)
-            return visitor.SaslScram512Auth(value.SaslScram512Auth);
-        if (value.ClientCertificateTlsAuth !== undefined)
-            return visitor.ClientCertificateTlsAuth(value.ClientCertificateTlsAuth);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.MSKAccessCredentials || (exports.MSKAccessCredentials = {}));
 const MSKStartPosition = {
     LATEST: "LATEST",
     TRIM_HORIZON: "TRIM_HORIZON",
 };
-exports.SelfManagedKafkaAccessConfigurationCredentials = void 0;
-(function (SelfManagedKafkaAccessConfigurationCredentials) {
-    SelfManagedKafkaAccessConfigurationCredentials.visit = (value, visitor) => {
-        if (value.BasicAuth !== undefined)
-            return visitor.BasicAuth(value.BasicAuth);
-        if (value.SaslScram512Auth !== undefined)
-            return visitor.SaslScram512Auth(value.SaslScram512Auth);
-        if (value.SaslScram256Auth !== undefined)
-            return visitor.SaslScram256Auth(value.SaslScram256Auth);
-        if (value.ClientCertificateTlsAuth !== undefined)
-            return visitor.ClientCertificateTlsAuth(value.ClientCertificateTlsAuth);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(exports.SelfManagedKafkaAccessConfigurationCredentials || (exports.SelfManagedKafkaAccessConfigurationCredentials = {}));
 const SelfManagedKafkaStartPosition = {
     LATEST: "LATEST",
     TRIM_HORIZON: "TRIM_HORIZON",
@@ -281,7 +249,7 @@ const PipeState = {
     UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
     UPDATING: "UPDATING",
 };
-class InternalException extends PipesServiceException {
+let InternalException$1 = class InternalException extends PipesServiceException$1 {
     name = "InternalException";
     $fault = "server";
     retryAfterSeconds;
@@ -294,8 +262,8 @@ class InternalException extends PipesServiceException {
         Object.setPrototypeOf(this, InternalException.prototype);
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
-class NotFoundException extends PipesServiceException {
+};
+let NotFoundException$1 = class NotFoundException extends PipesServiceException$1 {
     name = "NotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -306,8 +274,8 @@ class NotFoundException extends PipesServiceException {
         });
         Object.setPrototypeOf(this, NotFoundException.prototype);
     }
-}
-class ServiceQuotaExceededException extends PipesServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends PipesServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     resourceId;
@@ -326,8 +294,8 @@ class ServiceQuotaExceededException extends PipesServiceException {
         this.serviceCode = opts.serviceCode;
         this.quotaCode = opts.quotaCode;
     }
-}
-class ThrottlingException extends PipesServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends PipesServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     serviceCode;
@@ -344,8 +312,8 @@ class ThrottlingException extends PipesServiceException {
         this.quotaCode = opts.quotaCode;
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
-class ValidationException extends PipesServiceException {
+};
+let ValidationException$1 = class ValidationException extends PipesServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     fieldList;
@@ -358,784 +326,1266 @@ class ValidationException extends PipesServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.fieldList = opts.fieldList;
     }
-}
+};
 const RequestedPipeStateDescribeResponse = {
     DELETED: "DELETED",
     RUNNING: "RUNNING",
     STOPPED: "STOPPED",
 };
-const AwsVpcConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Subnets && { Subnets: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SecurityGroups && { SecurityGroups: smithyClient.SENSITIVE_STRING }),
-});
-const CapacityProviderStrategyItemFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.capacityProvider && { capacityProvider: smithyClient.SENSITIVE_STRING }),
-});
-const PipeEnrichmentHttpParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PathParameterValues && { PathParameterValues: smithyClient.SENSITIVE_STRING }),
-    ...(obj.HeaderParameters && { HeaderParameters: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryStringParameters && { QueryStringParameters: smithyClient.SENSITIVE_STRING }),
-});
-const PipeEnrichmentParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputTemplate && { InputTemplate: smithyClient.SENSITIVE_STRING }),
-    ...(obj.HttpParameters && { HttpParameters: PipeEnrichmentHttpParametersFilterSensitiveLog(obj.HttpParameters) }),
-});
-const PipeSourceActiveMQBrokerParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Credentials && { Credentials: obj.Credentials }),
-    ...(obj.QueueName && { QueueName: smithyClient.SENSITIVE_STRING }),
-});
-const FilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Pattern && { Pattern: smithyClient.SENSITIVE_STRING }),
-});
-const FilterCriteriaFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Filters && { Filters: obj.Filters.map((item) => FilterFilterSensitiveLog(item)) }),
-});
-const PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TopicName && { TopicName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ConsumerGroupID && { ConsumerGroupID: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Credentials && { Credentials: obj.Credentials }),
-});
-const PipeSourceRabbitMQBrokerParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Credentials && { Credentials: obj.Credentials }),
-    ...(obj.QueueName && { QueueName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.VirtualHost && { VirtualHost: smithyClient.SENSITIVE_STRING }),
-});
-const SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Subnets && { Subnets: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SecurityGroup && { SecurityGroup: smithyClient.SENSITIVE_STRING }),
-});
-const PipeSourceSelfManagedKafkaParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TopicName && { TopicName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AdditionalBootstrapServers && { AdditionalBootstrapServers: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ConsumerGroupID && { ConsumerGroupID: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Credentials && { Credentials: obj.Credentials }),
-    ...(obj.Vpc && { Vpc: SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog(obj.Vpc) }),
-});
-const PipeSourceParametersFilterSensitiveLog = (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),
-    }),
-});
-const NetworkConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.awsvpcConfiguration && {
-        awsvpcConfiguration: AwsVpcConfigurationFilterSensitiveLog(obj.awsvpcConfiguration),
-    }),
-});
-const PlacementConstraintFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.expression && { expression: smithyClient.SENSITIVE_STRING }),
-});
-const PlacementStrategyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.field && { field: smithyClient.SENSITIVE_STRING }),
-});
-const TagFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetEcsTaskParametersFilterSensitiveLog = (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: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }),
-});
-const PipeTargetEventBridgeEventBusParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.EndpointId && { EndpointId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DetailType && { DetailType: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Source && { Source: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetHttpParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PathParameterValues && { PathParameterValues: smithyClient.SENSITIVE_STRING }),
-    ...(obj.HeaderParameters && { HeaderParameters: smithyClient.SENSITIVE_STRING }),
-    ...(obj.QueryStringParameters && { QueryStringParameters: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetKinesisStreamParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PartitionKey && { PartitionKey: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetRedshiftDataParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Database && { Database: smithyClient.SENSITIVE_STRING }),
-    ...(obj.DbUser && { DbUser: smithyClient.SENSITIVE_STRING }),
-    ...(obj.StatementName && { StatementName: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Sqls && { Sqls: smithyClient.SENSITIVE_STRING }),
-});
-const SageMakerPipelineParameterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Value && { Value: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetSageMakerPipelineParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PipelineParameterList && {
-        PipelineParameterList: obj.PipelineParameterList.map((item) => SageMakerPipelineParameterFilterSensitiveLog(item)),
-    }),
-});
-const PipeTargetSqsQueueParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.MessageGroupId && { MessageGroupId: smithyClient.SENSITIVE_STRING }),
-    ...(obj.MessageDeduplicationId && { MessageDeduplicationId: smithyClient.SENSITIVE_STRING }),
-});
-const PipeTargetParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputTemplate && { InputTemplate: smithyClient.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),
-    }),
-});
-const CreatePipeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Description && { Description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SourceParameters && { SourceParameters: PipeSourceParametersFilterSensitiveLog(obj.SourceParameters) }),
-    ...(obj.EnrichmentParameters && {
-        EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters),
-    }),
-    ...(obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) }),
-    ...(obj.Tags && { Tags: smithyClient.SENSITIVE_STRING }),
-});
-const DescribePipeResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Description && { Description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SourceParameters && { SourceParameters: PipeSourceParametersFilterSensitiveLog(obj.SourceParameters) }),
-    ...(obj.EnrichmentParameters && {
-        EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters),
-    }),
-    ...(obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) }),
-    ...(obj.Tags && { Tags: smithyClient.SENSITIVE_STRING }),
-});
-const ListPipesRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListPipesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
-});
-const UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Credentials && { Credentials: obj.Credentials }),
-    ...(obj.Vpc && { Vpc: SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog(obj.Vpc) }),
-});
-const UpdatePipeSourceParametersFilterSensitiveLog = (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),
-    }),
-});
-const UpdatePipeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Description && { Description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.SourceParameters && { SourceParameters: UpdatePipeSourceParametersFilterSensitiveLog(obj.SourceParameters) }),
-    ...(obj.EnrichmentParameters && {
-        EnrichmentParameters: PipeEnrichmentParametersFilterSensitiveLog(obj.EnrichmentParameters),
-    }),
-    ...(obj.TargetParameters && { TargetParameters: PipeTargetParametersFilterSensitiveLog(obj.TargetParameters) }),
-});
-const TagResourceRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.tags && { tags: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_CreatePipeCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        Description: [],
-        DesiredState: [],
-        Enrichment: [],
-        EnrichmentParameters: (_) => smithyClient._json(_),
-        KmsKeyIdentifier: [],
-        LogConfiguration: (_) => smithyClient._json(_),
-        RoleArn: [],
-        Source: [],
-        SourceParameters: (_) => se_PipeSourceParameters(_),
-        Tags: (_) => smithyClient._json(_),
-        Target: [],
-        TargetParameters: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeletePipeCommand = async (input, context) => {
-    const b = 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();
-};
-const se_DescribePipeCommand = async (input, context) => {
-    const b = 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();
-};
-const se_ListPipesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/pipes");
-    const query = smithyClient.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();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = 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();
-};
-const se_StartPipeCommand = async (input, context) => {
-    const b = 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();
-};
-const se_StopPipeCommand = async (input, context) => {
-    const b = 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();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdatePipeCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        Description: [],
-        DesiredState: [],
-        Enrichment: [],
-        EnrichmentParameters: (_) => smithyClient._json(_),
-        KmsKeyIdentifier: [],
-        LogConfiguration: (_) => smithyClient._json(_),
-        RoleArn: [],
-        SourceParameters: (_) => smithyClient._json(_),
-        Target: [],
-        TargetParameters: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const de_CreatePipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeletePipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribePipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        Description: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        Enrichment: smithyClient.expectString,
-        EnrichmentParameters: smithyClient._json,
-        KmsKeyIdentifier: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogConfiguration: smithyClient._json,
-        Name: smithyClient.expectString,
-        RoleArn: smithyClient.expectString,
-        Source: smithyClient.expectString,
-        SourceParameters: (_) => de_PipeSourceParameters(_),
-        StateReason: smithyClient.expectString,
-        Tags: smithyClient._json,
-        Target: smithyClient.expectString,
-        TargetParameters: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListPipesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Pipes: (_) => de_PipeList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartPipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopPipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdatePipeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.pipes#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalException":
-        case "com.amazonaws.pipes#InternalException":
-            throw await de_InternalExceptionRes(parsedOutput);
-        case "NotFoundException":
-        case "com.amazonaws.pipes#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.pipes#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.pipes#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.pipes#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(PipesServiceException);
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        fieldList: smithyClient._json,
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_PipeSourceKinesisStreamParameters = (input, context) => {
-    return smithyClient.take(input, {
-        BatchSize: [],
-        DeadLetterConfig: smithyClient._json,
-        MaximumBatchingWindowInSeconds: [],
-        MaximumRecordAgeInSeconds: [],
-        MaximumRetryAttempts: [],
-        OnPartialBatchItemFailure: [],
-        ParallelizationFactor: [],
-        StartingPosition: [],
-        StartingPositionTimestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_PipeSourceParameters = (input, context) => {
-    return smithyClient.take(input, {
-        ActiveMQBrokerParameters: smithyClient._json,
-        DynamoDBStreamParameters: smithyClient._json,
-        FilterCriteria: smithyClient._json,
-        KinesisStreamParameters: (_) => se_PipeSourceKinesisStreamParameters(_),
-        ManagedStreamingKafkaParameters: smithyClient._json,
-        RabbitMQBrokerParameters: smithyClient._json,
-        SelfManagedKafkaParameters: smithyClient._json,
-        SqsQueueParameters: smithyClient._json,
-    });
-};
-const de_Pipe = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CurrentState: smithyClient.expectString,
-        DesiredState: smithyClient.expectString,
-        Enrichment: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        Source: smithyClient.expectString,
-        StateReason: smithyClient.expectString,
-        Target: smithyClient.expectString,
-    });
-};
-const de_PipeList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Pipe(entry);
-    });
-    return retVal;
-};
-const de_PipeSourceKinesisStreamParameters = (output, context) => {
-    return smithyClient.take(output, {
-        BatchSize: smithyClient.expectInt32,
-        DeadLetterConfig: smithyClient._json,
-        MaximumBatchingWindowInSeconds: smithyClient.expectInt32,
-        MaximumRecordAgeInSeconds: smithyClient.expectInt32,
-        MaximumRetryAttempts: smithyClient.expectInt32,
-        OnPartialBatchItemFailure: smithyClient.expectString,
-        ParallelizationFactor: smithyClient.expectInt32,
-        StartingPosition: smithyClient.expectString,
-        StartingPositionTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_PipeSourceParameters = (output, context) => {
-    return smithyClient.take(output, {
-        ActiveMQBrokerParameters: smithyClient._json,
-        DynamoDBStreamParameters: smithyClient._json,
-        FilterCriteria: smithyClient._json,
-        KinesisStreamParameters: (_) => de_PipeSourceKinesisStreamParameters(_),
-        ManagedStreamingKafkaParameters: smithyClient._json,
-        RabbitMQBrokerParameters: smithyClient._json,
-        SelfManagedKafkaParameters: smithyClient._json,
-        SqsQueueParameters: smithyClient._json,
-    });
-};
-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 _A = "Attempts";
+const _ABS = "AdditionalBootstrapServers";
+const _AMQBP = "ActiveMQBrokerParameters";
+const _AP = "ArrayProperties";
+const _API = "AssignPublicIp";
+const _AVC = "AwsVpcConfiguration";
+const _Ar = "Arn";
+const _BA = "BasicAuth";
+const _BAP = "BatchArrayProperties";
+const _BCO = "BatchContainerOverrides";
+const _BDO = "BatchDependsOn";
+const _BEV = "BatchEnvironmentVariable";
+const _BEVL = "BatchEnvironmentVariableList";
+const _BJD = "BatchJobDependency";
+const _BJP = "BatchJobParameters";
+const _BN = "BucketName";
+const _BO = "BucketOwner";
+const _BRR = "BatchResourceRequirement";
+const _BRRL = "BatchResourceRequirementsList";
+const _BRS = "BatchRetryStrategy";
+const _BS = "BatchSize";
+const _C = "Command";
+const _CCTA = "ClientCertificateTlsAuth";
+const _CE = "ConflictException";
+const _CGID = "ConsumerGroupID";
+const _CLLD = "CloudwatchLogsLogDestination";
+const _CLLDP = "CloudwatchLogsLogDestinationParameters";
+const _CO = "ContainerOverrides";
+const _CP = "CapacityProvider";
+const _CPR = "CreatePipeRequest";
+const _CPRr = "CreatePipeResponse";
+const _CPS = "CapacityProviderStrategy";
+const _CPSI = "CapacityProviderStrategyItem";
+const _CPr = "CreatePipe";
 const _CS = "CurrentState";
+const _CT = "CreationTime";
+const _CWLP = "CloudWatchLogsParameters";
+const _Cp = "Cpu";
+const _Cr = "Credentials";
+const _D = "Database";
+const _DDBSP = "DynamoDBStreamParameters";
+const _DLC = "DeadLetterConfig";
+const _DM = "DimensionMapping";
+const _DMi = "DimensionMappings";
+const _DN = "DimensionName";
+const _DO = "DependsOn";
+const _DP = "DeletePipe";
+const _DPR = "DeletePipeRequest";
+const _DPRe = "DeletePipeResponse";
+const _DPRes = "DescribePipeRequest";
+const _DPResc = "DescribePipeResponse";
+const _DPe = "DescribePipe";
 const _DS = "DesiredState";
+const _DSA = "DeliveryStreamArn";
+const _DT = "DetailType";
+const _DU = "DbUser";
+const _DV = "DimensionValue";
+const _DVT = "DimensionValueType";
+const _De = "Description";
+const _E = "Environment";
+const _EBDT = "EventBridgeDetailType";
+const _EBEBP = "EventBridgeEventBusParameters";
+const _EBEI = "EventBridgeEndpointId";
+const _EBES = "EventBridgeEventSource";
+const _ECO = "EcsContainerOverride";
+const _ECOL = "EcsContainerOverrideList";
+const _EEC = "EnableExecuteCommand";
+const _EECSMT = "EnableECSManagedTags";
+const _EEF = "EcsEnvironmentFile";
+const _EEFL = "EcsEnvironmentFileList";
+const _EES = "EcsEphemeralStorage";
+const _EEV = "EcsEnvironmentVariable";
+const _EEVL = "EcsEnvironmentVariableList";
+const _EF = "EnvironmentFiles";
+const _EI = "EndpointId";
+const _EIAO = "EcsInferenceAcceleratorOverride";
+const _EIAOL = "EcsInferenceAcceleratorOverrideList";
+const _EP = "EventPattern";
+const _EPn = "EnrichmentParameters";
+const _ERA = "ExecutionRoleArn";
+const _ERR = "EcsResourceRequirement";
+const _ERRL = "EcsResourceRequirementsList";
+const _ES = "EndpointString";
+const _ESp = "EphemeralStorage";
+const _ETO = "EcsTaskOverride";
+const _ETP = "EcsTaskParameters";
+const _ETU = "EpochTimeUnit";
+const _En = "Enrichment";
+const _F = "Filter";
+const _FC = "FilterCriteria";
+const _FL = "FilterList";
+const _FLD = "FirehoseLogDestination";
+const _FLDP = "FirehoseLogDestinationParameters";
+const _Fi = "Filters";
+const _G = "Group";
+const _HP = "HeaderParameters";
+const _HPM = "HeaderParametersMap";
+const _HPt = "HttpParameters";
+const _HV = "HeaderValue";
+const _IAO = "InferenceAcceleratorOverrides";
+const _IE = "InternalException";
+const _IED = "IncludeExecutionData";
+const _IT = "InputTemplate";
+const _ITn = "InstanceType";
+const _ITnv = "InvocationType";
+const _JD = "JobDefinition";
+const _JI = "JobId";
+const _JN = "JobName";
+const _K = "Key";
+const _KBS = "KafkaBootstrapServers";
+const _KKI = "KmsKeyIdentifier";
+const _KPK = "KinesisPartitionKey";
+const _KSP = "KinesisStreamParameters";
+const _KTN = "KafkaTopicName";
 const _L = "Limit";
+const _LC = "LogConfiguration";
+const _LFP = "LambdaFunctionParameters";
+const _LGA = "LogGroupArn";
+const _LMT = "LastModifiedTime";
+const _LP = "ListPipes";
+const _LPR = "ListPipesRequest";
+const _LPRi = "ListPipesResponse";
+const _LSN = "LogStreamName";
+const _LT = "LaunchType";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _Le = "Level";
+const _M = "Memory";
+const _MBWIS = "MaximumBatchingWindowInSeconds";
+const _MDI = "MessageDeduplicationId";
+const _MGI = "MessageGroupId";
+const _MMAM = "MultiMeasureAttributeMapping";
+const _MMAMu = "MultiMeasureAttributeMappings";
+const _MMAN = "MultiMeasureAttributeName";
+const _MMM = "MultiMeasureMapping";
+const _MMMu = "MultiMeasureMappings";
+const _MMN = "MultiMeasureName";
+const _MN = "MeasureName";
+const _MQBAC = "MQBrokerAccessCredentials";
+const _MQBQN = "MQBrokerQueueName";
+const _MR = "MemoryReservation";
+const _MRA = "MaximumRetryAttempts";
+const _MRAIS = "MaximumRecordAgeInSeconds";
+const _MSKAC = "MSKAccessCredentials";
+const _MSKP = "ManagedStreamingKafkaParameters";
+const _MV = "MeasureValue";
+const _MVT = "MeasureValueType";
+const _N = "Name";
+const _NC = "NetworkConfiguration";
+const _NFE = "NotFoundException";
 const _NP = "NamePrefix";
 const _NT = "NextToken";
-const _SP = "SourcePrefix";
-const _TP = "TargetPrefix";
+const _O = "Overrides";
+const _OF = "OutputFormat";
+const _OPBIF = "OnPartialBatchItemFailure";
+const _P = "Pattern";
+const _PC = "PlacementConstraints";
+const _PCE = "PlacementConstraintExpression";
+const _PCl = "PlacementConstraint";
+const _PD = "PipeDescription";
+const _PEHP = "PipeEnrichmentHttpParameters";
+const _PEP = "PipeEnrichmentParameters";
+const _PF = "ParallelizationFactor";
+const _PK = "PartitionKey";
+const _PL = "PipeList";
+const _PLC = "PipeLogConfiguration";
+const _PLCP = "PipeLogConfigurationParameters";
+const _PP = "PathParameter";
+const _PPL = "PipelineParameterList";
+const _PPLa = "PathParameterList";
+const _PPV = "PathParameterValues";
+const _PS = "PlacementStrategy";
+const _PSAMQBP = "PipeSourceActiveMQBrokerParameters";
+const _PSDDBSP = "PipeSourceDynamoDBStreamParameters";
+const _PSF = "PlacementStrategyField";
+const _PSKSP = "PipeSourceKinesisStreamParameters";
+const _PSMSKP = "PipeSourceManagedStreamingKafkaParameters";
+const _PSP = "PipeSourceParameters";
+const _PSRMQBP = "PipeSourceRabbitMQBrokerParameters";
+const _PSSMKP = "PipeSourceSelfManagedKafkaParameters";
+const _PSSQP = "PipeSourceSqsQueueParameters";
+const _PSl = "PlacementStrategies";
+const _PT = "PropagateTags";
+const _PTBJP = "PipeTargetBatchJobParameters";
+const _PTCWLP = "PipeTargetCloudWatchLogsParameters";
+const _PTEBEBP = "PipeTargetEventBridgeEventBusParameters";
+const _PTETP = "PipeTargetEcsTaskParameters";
+const _PTHP = "PipeTargetHttpParameters";
+const _PTKSP = "PipeTargetKinesisStreamParameters";
+const _PTLFP = "PipeTargetLambdaFunctionParameters";
+const _PTP = "PipeTargetParameters";
+const _PTRDP = "PipeTargetRedshiftDataParameters";
+const _PTSMP = "PipeTargetStateMachineParameters";
+const _PTSMPP = "PipeTargetSageMakerPipelineParameters";
+const _PTSQP = "PipeTargetSqsQueueParameters";
+const _PTTP = "PipeTargetTimestreamParameters";
+const _PV = "PlatformVersion";
+const _Pa = "Parameters";
+const _Pi = "Pipes";
+const _Pip = "Pipe";
+const _Pr = "Prefix";
+const _QN = "QueueName";
+const _QSP = "QueryStringParameters";
+const _QSPM = "QueryStringParametersMap";
+const _QSV = "QueryStringValue";
+const _R = "Resources";
+const _RA = "RoleArn";
+const _RA_ = "Retry-After";
+const _RDP = "RedshiftDataParameters";
+const _RI = "ReferenceId";
+const _RMQBP = "RabbitMQBrokerParameters";
+const _RR = "ResourceRequirements";
+const _RS = "RetryStrategy";
+const _S = "Sql";
+const _SFSMP = "StepFunctionStateMachineParameters";
+const _SG = "SecurityGroup";
+const _SGI = "SecurityGroupId";
+const _SGIe = "SecurityGroupIds";
+const _SGe = "SecurityGroups";
+const _SI = "SubnetId";
+const _SIu = "SubnetIds";
+const _SLD = "S3LogDestination";
+const _SLDP = "S3LogDestinationParameters";
+const _SMA = "SecretManagerArn";
+const _SMKACC = "SelfManagedKafkaAccessConfigurationCredentials";
+const _SMKACV = "SelfManagedKafkaAccessConfigurationVpc";
+const _SMKP = "SelfManagedKafkaParameters";
+const _SMM = "SingleMeasureMappings";
+const _SMMi = "SingleMeasureMapping";
+const _SMPP = "SageMakerPipelineParameters";
+const _SMPPL = "SageMakerPipelineParameterList";
+const _SMPPN = "SageMakerPipelineParameterName";
+const _SMPPV = "SageMakerPipelineParameterValue";
+const _SMPPa = "SageMakerPipelineParameter";
+const _SN = "StatementName";
+const _SP = "SourceParameters";
+const _SPR = "StartPipeRequest";
+const _SPRt = "StartPipeResponse";
+const _SPRto = "StopPipeRequest";
+const _SPRtop = "StopPipeResponse";
+const _SPT = "StartingPositionTimestamp";
+const _SPo = "SourcePrefix";
+const _SPt = "StartingPosition";
+const _SPta = "StartPipe";
+const _SPto = "StopPipe";
+const _SQEE = "ServiceQuotaExceededException";
+const _SQP = "SqsQueueParameters";
+const _SR = "StateReason";
+const _SRCC = "ServerRootCaCertificate";
+const _SSA = "SaslScram512Auth";
+const _SSAa = "SaslScram256Auth";
+const _Si = "Size";
+const _So = "Source";
+const _Sq = "Sqls";
+const _Su = "Subnet";
+const _Sub = "Subnets";
+const _T = "Type";
+const _TC = "TaskCount";
+const _TDA = "TaskDefinitionArn";
+const _TE = "ThrottlingException";
+const _TF = "TimestampFormat";
+const _TFT = "TimeFieldType";
+const _TL = "TagList";
+const _TM = "TagMap";
+const _TN = "TopicName";
+const _TP = "TargetParameters";
+const _TPa = "TargetPrefix";
+const _TPi = "TimestreamParameters";
+const _TR = "TagResource";
+const _TRA = "TaskRoleArn";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TV = "TagValue";
+const _TVi = "TimeValue";
+const _Ta = "Target";
+const _Tag = "Tags";
+const _Tag_ = "Tag";
+const _Ti = "Timestamp";
+const _Tim = "Time";
+const _UP = "UpdatePipe";
+const _UPR = "UpdatePipeRequest";
+const _UPRp = "UpdatePipeResponse";
+const _UPSAMQBP = "UpdatePipeSourceActiveMQBrokerParameters";
+const _UPSDDBSP = "UpdatePipeSourceDynamoDBStreamParameters";
+const _UPSKSP = "UpdatePipeSourceKinesisStreamParameters";
+const _UPSMSKP = "UpdatePipeSourceManagedStreamingKafkaParameters";
+const _UPSP = "UpdatePipeSourceParameters";
+const _UPSRMQBP = "UpdatePipeSourceRabbitMQBrokerParameters";
+const _UPSSMKP = "UpdatePipeSourceSelfManagedKafkaParameters";
+const _UPSSQP = "UpdatePipeSourceSqsQueueParameters";
+const _UR = "UntagResource";
+const _URI = "URI";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _VH = "VirtualHost";
+const _VV = "VersionValue";
+const _Vp = "Vpc";
+const _WE = "WithEvent";
+const _aC = "awsvpcConfiguration";
+const _b = "base";
+const _c = "client";
+const _cP = "capacityProvider";
+const _dN = "deviceName";
+const _dT = "deviceType";
+const _e = "error";
+const _ex = "expression";
+const _f = "field";
+const _fL = "fieldList";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _m = "message";
+const _n = "name";
+const _qC = "quotaCode";
+const _rA = "resourceArn";
 const _rAS = "retryAfterSeconds";
-const _ra = "retry-after";
+const _rI = "resourceId";
+const _rT = "resourceType";
+const _s = "server";
+const _sC = "serviceCode";
+const _sIGB = "sizeInGiB";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.pipes";
+const _t = "type";
 const _tK = "tagKeys";
+const _ta = "tags";
+const _v = "value";
+const _w = "weight";
+const n0 = "com.amazonaws.pipes";
+var CapacityProvider = [0, n0, _CP, 8, 0];
+var Database = [0, n0, _D, 8, 0];
+var DbUser = [0, n0, _DU, 8, 0];
+var EndpointString = [0, n0, _ES, 8, 0];
+var EventBridgeDetailType = [0, n0, _EBDT, 8, 0];
+var EventBridgeEndpointId = [0, n0, _EBEI, 8, 0];
+var EventBridgeEventSource = [0, n0, _EBES, 8, 0];
+var EventPattern = [0, n0, _EP, 8, 0];
+var HeaderValue = [0, n0, _HV, 8, 0];
+var InputTemplate = [0, n0, _IT, 8, 0];
+var KafkaTopicName = [0, n0, _KTN, 8, 0];
+var KinesisPartitionKey = [0, n0, _KPK, 8, 0];
+var MessageDeduplicationId = [0, n0, _MDI, 8, 0];
+var MessageGroupId = [0, n0, _MGI, 8, 0];
+var MQBrokerQueueName = [0, n0, _MQBQN, 8, 0];
+var NextToken = [0, n0, _NT, 8, 0];
+var PathParameter = [0, n0, _PP, 8, 0];
+var PipeDescription = [0, n0, _PD, 8, 0];
+var PlacementConstraintExpression = [0, n0, _PCE, 8, 0];
+var PlacementStrategyField = [0, n0, _PSF, 8, 0];
+var QueryStringValue = [0, n0, _QSV, 8, 0];
+var ReferenceId = [0, n0, _RI, 8, 0];
+var SageMakerPipelineParameterName = [0, n0, _SMPPN, 8, 0];
+var SageMakerPipelineParameterValue = [0, n0, _SMPPV, 8, 0];
+var SecurityGroup = [0, n0, _SG, 8, 0];
+var SecurityGroupId = [0, n0, _SGI, 8, 0];
+var Sql = [0, n0, _S, 8, 0];
+var StatementName = [0, n0, _SN, 8, 0];
+var Subnet = [0, n0, _Su, 8, 0];
+var SubnetId = [0, n0, _SI, 8, 0];
+var TagValue = [0, n0, _TV, 8, 0];
+var URI = [0, n0, _URI, 8, 0];
+var AwsVpcConfiguration = [
+    3,
+    n0,
+    _AVC,
+    0,
+    [_Sub, _SGe, _API],
+    [[() => Subnets, 0], [() => SecurityGroups, 0], 0],
+];
+var BatchArrayProperties = [3, n0, _BAP, 0, [_Si], [1]];
+var BatchContainerOverrides = [
+    3,
+    n0,
+    _BCO,
+    0,
+    [_C, _E, _ITn, _RR],
+    [64 | 0, () => BatchEnvironmentVariableList, 0, () => BatchResourceRequirementsList],
+];
+var BatchEnvironmentVariable = [3, n0, _BEV, 0, [_N, _V], [0, 0]];
+var BatchJobDependency = [3, n0, _BJD, 0, [_JI, _T], [0, 0]];
+var BatchResourceRequirement = [3, n0, _BRR, 0, [_T, _V], [0, 0]];
+var BatchRetryStrategy = [3, n0, _BRS, 0, [_A], [1]];
+var CapacityProviderStrategyItem = [
+    3,
+    n0,
+    _CPSI,
+    0,
+    [_cP, _w, _b],
+    [[() => CapacityProvider, 0], 1, 1],
+];
+var CloudwatchLogsLogDestination = [3, n0, _CLLD, 0, [_LGA], [0]];
+var CloudwatchLogsLogDestinationParameters = [3, n0, _CLLDP, 0, [_LGA], [0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreatePipeRequest = [
+    3,
+    n0,
+    _CPR,
+    0,
+    [_N, _De, _DS, _So, _SP, _En, _EPn, _Ta, _TP, _RA, _Tag, _LC, _KKI],
+    [
+        [0, 1],
+        [() => PipeDescription, 0],
+        0,
+        0,
+        [() => PipeSourceParameters, 0],
+        0,
+        [() => PipeEnrichmentParameters, 0],
+        0,
+        [() => PipeTargetParameters, 0],
+        0,
+        [() => TagMap, 0],
+        () => PipeLogConfigurationParameters,
+        0,
+    ],
+];
+var CreatePipeResponse = [
+    3,
+    n0,
+    _CPRr,
+    0,
+    [_Ar, _N, _DS, _CS, _CT, _LMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var DeadLetterConfig = [3, n0, _DLC, 0, [_Ar], [0]];
+var DeletePipeRequest = [3, n0, _DPR, 0, [_N], [[0, 1]]];
+var DeletePipeResponse = [
+    3,
+    n0,
+    _DPRe,
+    0,
+    [_Ar, _N, _DS, _CS, _CT, _LMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var DescribePipeRequest = [3, n0, _DPRes, 0, [_N], [[0, 1]]];
+var DescribePipeResponse = [
+    3,
+    n0,
+    _DPResc,
+    0,
+    [_Ar, _N, _De, _DS, _CS, _SR, _So, _SP, _En, _EPn, _Ta, _TP, _RA, _Tag, _CT, _LMT, _LC, _KKI],
+    [
+        0,
+        0,
+        [() => PipeDescription, 0],
+        0,
+        0,
+        0,
+        0,
+        [() => PipeSourceParameters, 0],
+        0,
+        [() => PipeEnrichmentParameters, 0],
+        0,
+        [() => PipeTargetParameters, 0],
+        0,
+        [() => TagMap, 0],
+        4,
+        4,
+        () => PipeLogConfiguration,
+        0,
+    ],
+];
+var DimensionMapping = [3, n0, _DM, 0, [_DV, _DVT, _DN], [0, 0, 0]];
+var EcsContainerOverride = [
+    3,
+    n0,
+    _ECO,
+    0,
+    [_C, _Cp, _E, _EF, _M, _MR, _N, _RR],
+    [
+        64 | 0,
+        1,
+        () => EcsEnvironmentVariableList,
+        () => EcsEnvironmentFileList,
+        1,
+        1,
+        0,
+        () => EcsResourceRequirementsList,
+    ],
+];
+var EcsEnvironmentFile = [3, n0, _EEF, 0, [_t, _v], [0, 0]];
+var EcsEnvironmentVariable = [3, n0, _EEV, 0, [_n, _v], [0, 0]];
+var EcsEphemeralStorage = [3, n0, _EES, 0, [_sIGB], [1]];
+var EcsInferenceAcceleratorOverride = [3, n0, _EIAO, 0, [_dN, _dT], [0, 0]];
+var EcsResourceRequirement = [3, n0, _ERR, 0, [_t, _v], [0, 0]];
+var EcsTaskOverride = [
+    3,
+    n0,
+    _ETO,
+    0,
+    [_CO, _Cp, _ESp, _ERA, _IAO, _M, _TRA],
+    [() => EcsContainerOverrideList, 0, () => EcsEphemeralStorage, 0, () => EcsInferenceAcceleratorOverrideList, 0, 0],
+];
+var Filter = [3, n0, _F, 0, [_P], [[() => EventPattern, 0]]];
+var FilterCriteria = [3, n0, _FC, 0, [_Fi], [[() => FilterList, 0]]];
+var FirehoseLogDestination = [3, n0, _FLD, 0, [_DSA], [0]];
+var FirehoseLogDestinationParameters = [3, n0, _FLDP, 0, [_DSA], [0]];
+var InternalException = [
+    -3,
+    n0,
+    _IE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_m, _rAS],
+    [
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA_,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalException, InternalException$1);
+var ListPipesRequest = [
+    3,
+    n0,
+    _LPR,
+    0,
+    [_NP, _DS, _CS, _SPo, _TPa, _NT, _L],
+    [
+        [
+            0,
+            {
+                [_hQ]: _NP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _DS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _CS,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _SPo,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _TPa,
+            },
+        ],
+        [
+            () => NextToken,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _L,
+            },
+        ],
+    ],
+];
+var ListPipesResponse = [
+    3,
+    n0,
+    _LPRi,
+    0,
+    [_Pi, _NT],
+    [() => PipeList, [() => NextToken, 0]],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [[() => TagMap, 0]]];
+var MultiMeasureAttributeMapping = [3, n0, _MMAM, 0, [_MV, _MVT, _MMAN], [0, 0, 0]];
+var MultiMeasureMapping = [
+    3,
+    n0,
+    _MMM,
+    0,
+    [_MMN, _MMAMu],
+    [0, () => MultiMeasureAttributeMappings],
+];
+var NetworkConfiguration = [3, n0, _NC, 0, [_aC], [[() => AwsVpcConfiguration, 0]]];
+var NotFoundException = [
+    -3,
+    n0,
+    _NFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotFoundException, NotFoundException$1);
+var Pipe = [
+    3,
+    n0,
+    _Pip,
+    0,
+    [_N, _Ar, _DS, _CS, _SR, _CT, _LMT, _So, _Ta, _En],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0],
+];
+var PipeEnrichmentHttpParameters = [
+    3,
+    n0,
+    _PEHP,
+    0,
+    [_PPV, _HP, _QSP],
+    [
+        [() => PathParameterList, 0],
+        [() => HeaderParametersMap, 0],
+        [() => QueryStringParametersMap, 0],
+    ],
+];
+var PipeEnrichmentParameters = [
+    3,
+    n0,
+    _PEP,
+    0,
+    [_IT, _HPt],
+    [
+        [() => InputTemplate, 0],
+        [() => PipeEnrichmentHttpParameters, 0],
+    ],
+];
+var PipeLogConfiguration = [
+    3,
+    n0,
+    _PLC,
+    0,
+    [_SLD, _FLD, _CLLD, _Le, _IED],
+    [() => S3LogDestination, () => FirehoseLogDestination, () => CloudwatchLogsLogDestination, 0, 64 | 0],
+];
+var PipeLogConfigurationParameters = [
+    3,
+    n0,
+    _PLCP,
+    0,
+    [_SLD, _FLD, _CLLD, _Le, _IED],
+    [
+        () => S3LogDestinationParameters,
+        () => FirehoseLogDestinationParameters,
+        () => CloudwatchLogsLogDestinationParameters,
+        0,
+        64 | 0,
+    ],
+];
+var PipeSourceActiveMQBrokerParameters = [
+    3,
+    n0,
+    _PSAMQBP,
+    0,
+    [_Cr, _QN, _BS, _MBWIS],
+    [() => MQBrokerAccessCredentials, [() => MQBrokerQueueName, 0], 1, 1],
+];
+var PipeSourceDynamoDBStreamParameters = [
+    3,
+    n0,
+    _PSDDBSP,
+    0,
+    [_BS, _DLC, _OPBIF, _MBWIS, _MRAIS, _MRA, _PF, _SPt],
+    [1, () => DeadLetterConfig, 0, 1, 1, 1, 1, 0],
+];
+var PipeSourceKinesisStreamParameters = [
+    3,
+    n0,
+    _PSKSP,
+    0,
+    [_BS, _DLC, _OPBIF, _MBWIS, _MRAIS, _MRA, _PF, _SPt, _SPT],
+    [1, () => DeadLetterConfig, 0, 1, 1, 1, 1, 0, 4],
+];
+var PipeSourceManagedStreamingKafkaParameters = [
+    3,
+    n0,
+    _PSMSKP,
+    0,
+    [_TN, _SPt, _BS, _MBWIS, _CGID, _Cr],
+    [[() => KafkaTopicName, 0], 0, 1, 1, [() => URI, 0], () => MSKAccessCredentials],
+];
+var PipeSourceParameters = [
+    3,
+    n0,
+    _PSP,
+    0,
+    [_FC, _KSP, _DDBSP, _SQP, _AMQBP, _RMQBP, _MSKP, _SMKP],
+    [
+        [() => FilterCriteria, 0],
+        () => PipeSourceKinesisStreamParameters,
+        () => PipeSourceDynamoDBStreamParameters,
+        () => PipeSourceSqsQueueParameters,
+        [() => PipeSourceActiveMQBrokerParameters, 0],
+        [() => PipeSourceRabbitMQBrokerParameters, 0],
+        [() => PipeSourceManagedStreamingKafkaParameters, 0],
+        [() => PipeSourceSelfManagedKafkaParameters, 0],
+    ],
+];
+var PipeSourceRabbitMQBrokerParameters = [
+    3,
+    n0,
+    _PSRMQBP,
+    0,
+    [_Cr, _QN, _VH, _BS, _MBWIS],
+    [() => MQBrokerAccessCredentials, [() => MQBrokerQueueName, 0], [() => URI, 0], 1, 1],
+];
+var PipeSourceSelfManagedKafkaParameters = [
+    3,
+    n0,
+    _PSSMKP,
+    0,
+    [_TN, _SPt, _ABS, _BS, _MBWIS, _CGID, _Cr, _SRCC, _Vp],
+    [
+        [() => KafkaTopicName, 0],
+        0,
+        [() => KafkaBootstrapServers, 0],
+        1,
+        1,
+        [() => URI, 0],
+        () => SelfManagedKafkaAccessConfigurationCredentials,
+        0,
+        [() => SelfManagedKafkaAccessConfigurationVpc, 0],
+    ],
+];
+var PipeSourceSqsQueueParameters = [3, n0, _PSSQP, 0, [_BS, _MBWIS], [1, 1]];
+var PipeTargetBatchJobParameters = [
+    3,
+    n0,
+    _PTBJP,
+    0,
+    [_JD, _JN, _AP, _RS, _CO, _DO, _Pa],
+    [
+        0,
+        0,
+        () => BatchArrayProperties,
+        () => BatchRetryStrategy,
+        () => BatchContainerOverrides,
+        () => BatchDependsOn,
+        128 | 0,
+    ],
+];
+var PipeTargetCloudWatchLogsParameters = [3, n0, _PTCWLP, 0, [_LSN, _Ti], [0, 0]];
+var PipeTargetEcsTaskParameters = [
+    3,
+    n0,
+    _PTETP,
+    0,
+    [_TDA, _TC, _LT, _NC, _PV, _G, _CPS, _EECSMT, _EEC, _PC, _PS, _PT, _RI, _O, _Tag],
+    [
+        0,
+        1,
+        0,
+        [() => NetworkConfiguration, 0],
+        0,
+        0,
+        [() => CapacityProviderStrategy, 0],
+        2,
+        2,
+        [() => PlacementConstraints, 0],
+        [() => PlacementStrategies, 0],
+        0,
+        [() => ReferenceId, 0],
+        () => EcsTaskOverride,
+        [() => TagList, 0],
+    ],
+];
+var PipeTargetEventBridgeEventBusParameters = [
+    3,
+    n0,
+    _PTEBEBP,
+    0,
+    [_EI, _DT, _So, _R, _Tim],
+    [[() => EventBridgeEndpointId, 0], [() => EventBridgeDetailType, 0], [() => EventBridgeEventSource, 0], 64 | 0, 0],
+];
+var PipeTargetHttpParameters = [
+    3,
+    n0,
+    _PTHP,
+    0,
+    [_PPV, _HP, _QSP],
+    [
+        [() => PathParameterList, 0],
+        [() => HeaderParametersMap, 0],
+        [() => QueryStringParametersMap, 0],
+    ],
+];
+var PipeTargetKinesisStreamParameters = [
+    3,
+    n0,
+    _PTKSP,
+    0,
+    [_PK],
+    [[() => KinesisPartitionKey, 0]],
+];
+var PipeTargetLambdaFunctionParameters = [3, n0, _PTLFP, 0, [_ITnv], [0]];
+var PipeTargetParameters = [
+    3,
+    n0,
+    _PTP,
+    0,
+    [_IT, _LFP, _SFSMP, _KSP, _ETP, _BJP, _SQP, _HPt, _RDP, _SMPP, _EBEBP, _CWLP, _TPi],
+    [
+        [() => InputTemplate, 0],
+        () => PipeTargetLambdaFunctionParameters,
+        () => PipeTargetStateMachineParameters,
+        [() => PipeTargetKinesisStreamParameters, 0],
+        [() => PipeTargetEcsTaskParameters, 0],
+        () => PipeTargetBatchJobParameters,
+        [() => PipeTargetSqsQueueParameters, 0],
+        [() => PipeTargetHttpParameters, 0],
+        [() => PipeTargetRedshiftDataParameters, 0],
+        [() => PipeTargetSageMakerPipelineParameters, 0],
+        [() => PipeTargetEventBridgeEventBusParameters, 0],
+        () => PipeTargetCloudWatchLogsParameters,
+        () => PipeTargetTimestreamParameters,
+    ],
+];
+var PipeTargetRedshiftDataParameters = [
+    3,
+    n0,
+    _PTRDP,
+    0,
+    [_SMA, _D, _DU, _SN, _WE, _Sq],
+    [0, [() => Database, 0], [() => DbUser, 0], [() => StatementName, 0], 2, [() => Sqls, 0]],
+];
+var PipeTargetSageMakerPipelineParameters = [
+    3,
+    n0,
+    _PTSMPP,
+    0,
+    [_PPL],
+    [[() => SageMakerPipelineParameterList, 0]],
+];
+var PipeTargetSqsQueueParameters = [
+    3,
+    n0,
+    _PTSQP,
+    0,
+    [_MGI, _MDI],
+    [
+        [() => MessageGroupId, 0],
+        [() => MessageDeduplicationId, 0],
+    ],
+];
+var PipeTargetStateMachineParameters = [3, n0, _PTSMP, 0, [_ITnv], [0]];
+var PipeTargetTimestreamParameters = [
+    3,
+    n0,
+    _PTTP,
+    0,
+    [_TVi, _ETU, _TFT, _TF, _VV, _DMi, _SMM, _MMMu],
+    [0, 0, 0, 0, 0, () => DimensionMappings, () => SingleMeasureMappings, () => MultiMeasureMappings],
+];
+var PlacementConstraint = [
+    3,
+    n0,
+    _PCl,
+    0,
+    [_t, _ex],
+    [0, [() => PlacementConstraintExpression, 0]],
+];
+var PlacementStrategy = [3, n0, _PS, 0, [_t, _f], [0, [() => PlacementStrategyField, 0]]];
+var S3LogDestination = [3, n0, _SLD, 0, [_BN, _Pr, _BO, _OF], [0, 0, 0, 0]];
+var S3LogDestinationParameters = [3, n0, _SLDP, 0, [_BN, _BO, _OF, _Pr], [0, 0, 0, 0]];
+var SageMakerPipelineParameter = [
+    3,
+    n0,
+    _SMPPa,
+    0,
+    [_N, _V],
+    [
+        [() => SageMakerPipelineParameterName, 0],
+        [() => SageMakerPipelineParameterValue, 0],
+    ],
+];
+var SelfManagedKafkaAccessConfigurationVpc = [
+    3,
+    n0,
+    _SMKACV,
+    0,
+    [_Sub, _SG],
+    [
+        [() => SubnetIds, 0],
+        [() => SecurityGroupIds, 0],
+    ],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m, _rI, _rT, _sC, _qC],
+    [0, 0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var SingleMeasureMapping = [3, n0, _SMMi, 0, [_MV, _MVT, _MN], [0, 0, 0]];
+var StartPipeRequest = [3, n0, _SPR, 0, [_N], [[0, 1]]];
+var StartPipeResponse = [
+    3,
+    n0,
+    _SPRt,
+    0,
+    [_Ar, _N, _DS, _CS, _CT, _LMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var StopPipeRequest = [3, n0, _SPRto, 0, [_N], [[0, 1]]];
+var StopPipeResponse = [
+    3,
+    n0,
+    _SPRtop,
+    0,
+    [_Ar, _N, _DS, _CS, _CT, _LMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var Tag = [3, n0, _Tag_, 0, [_K, _V], [0, [() => TagValue, 0]]];
+var TagResourceRequest = [
+    3,
+    n0,
+    _TRR,
+    0,
+    [_rA, _ta],
+    [
+        [0, 1],
+        [() => TagMap, 0],
+    ],
+];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _sC, _qC, _rAS],
+    [
+        0,
+        0,
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA_,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdatePipeRequest = [
+    3,
+    n0,
+    _UPR,
+    0,
+    [_N, _De, _DS, _SP, _En, _EPn, _Ta, _TP, _RA, _LC, _KKI],
+    [
+        [0, 1],
+        [() => PipeDescription, 0],
+        0,
+        [() => UpdatePipeSourceParameters, 0],
+        0,
+        [() => PipeEnrichmentParameters, 0],
+        0,
+        [() => PipeTargetParameters, 0],
+        0,
+        () => PipeLogConfigurationParameters,
+        0,
+    ],
+];
+var UpdatePipeResponse = [
+    3,
+    n0,
+    _UPRp,
+    0,
+    [_Ar, _N, _DS, _CS, _CT, _LMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var UpdatePipeSourceActiveMQBrokerParameters = [
+    3,
+    n0,
+    _UPSAMQBP,
+    0,
+    [_Cr, _BS, _MBWIS],
+    [() => MQBrokerAccessCredentials, 1, 1],
+];
+var UpdatePipeSourceDynamoDBStreamParameters = [
+    3,
+    n0,
+    _UPSDDBSP,
+    0,
+    [_BS, _DLC, _OPBIF, _MBWIS, _MRAIS, _MRA, _PF],
+    [1, () => DeadLetterConfig, 0, 1, 1, 1, 1],
+];
+var UpdatePipeSourceKinesisStreamParameters = [
+    3,
+    n0,
+    _UPSKSP,
+    0,
+    [_BS, _DLC, _OPBIF, _MBWIS, _MRAIS, _MRA, _PF],
+    [1, () => DeadLetterConfig, 0, 1, 1, 1, 1],
+];
+var UpdatePipeSourceManagedStreamingKafkaParameters = [
+    3,
+    n0,
+    _UPSMSKP,
+    0,
+    [_BS, _Cr, _MBWIS],
+    [1, () => MSKAccessCredentials, 1],
+];
+var UpdatePipeSourceParameters = [
+    3,
+    n0,
+    _UPSP,
+    0,
+    [_FC, _KSP, _DDBSP, _SQP, _AMQBP, _RMQBP, _MSKP, _SMKP],
+    [
+        [() => FilterCriteria, 0],
+        () => UpdatePipeSourceKinesisStreamParameters,
+        () => UpdatePipeSourceDynamoDBStreamParameters,
+        () => UpdatePipeSourceSqsQueueParameters,
+        () => UpdatePipeSourceActiveMQBrokerParameters,
+        () => UpdatePipeSourceRabbitMQBrokerParameters,
+        () => UpdatePipeSourceManagedStreamingKafkaParameters,
+        [() => UpdatePipeSourceSelfManagedKafkaParameters, 0],
+    ],
+];
+var UpdatePipeSourceRabbitMQBrokerParameters = [
+    3,
+    n0,
+    _UPSRMQBP,
+    0,
+    [_Cr, _BS, _MBWIS],
+    [() => MQBrokerAccessCredentials, 1, 1],
+];
+var UpdatePipeSourceSelfManagedKafkaParameters = [
+    3,
+    n0,
+    _UPSSMKP,
+    0,
+    [_BS, _MBWIS, _Cr, _SRCC, _Vp],
+    [1, 1, () => SelfManagedKafkaAccessConfigurationCredentials, 0, [() => SelfManagedKafkaAccessConfigurationVpc, 0]],
+];
+var UpdatePipeSourceSqsQueueParameters = [3, n0, _UPSSQP, 0, [_BS, _MBWIS], [1, 1]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _fL],
+    [0, () => ValidationExceptionFieldList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_n, _m], [0, 0]];
+var PipesServiceException = [-3, _sm, "PipesServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(PipesServiceException, PipesServiceException$1);
+var BatchDependsOn = [1, n0, _BDO, 0, () => BatchJobDependency];
+var BatchEnvironmentVariableList = [1, n0, _BEVL, 0, () => BatchEnvironmentVariable];
+var BatchResourceRequirementsList = [1, n0, _BRRL, 0, () => BatchResourceRequirement];
+var CapacityProviderStrategy = [1, n0, _CPS, 0, [() => CapacityProviderStrategyItem, 0]];
+var DimensionMappings = [1, n0, _DMi, 0, () => DimensionMapping];
+var EcsContainerOverrideList = [1, n0, _ECOL, 0, () => EcsContainerOverride];
+var EcsEnvironmentFileList = [1, n0, _EEFL, 0, () => EcsEnvironmentFile];
+var EcsEnvironmentVariableList = [1, n0, _EEVL, 0, () => EcsEnvironmentVariable];
+var EcsInferenceAcceleratorOverrideList = [
+    1,
+    n0,
+    _EIAOL,
+    0,
+    () => EcsInferenceAcceleratorOverride,
+];
+var EcsResourceRequirementsList = [1, n0, _ERRL, 0, () => EcsResourceRequirement];
+var FilterList = [1, n0, _FL, 0, [() => Filter, 0]];
+var KafkaBootstrapServers = [1, n0, _KBS, 0, [() => EndpointString, 0]];
+var MultiMeasureAttributeMappings = [1, n0, _MMAMu, 0, () => MultiMeasureAttributeMapping];
+var MultiMeasureMappings = [1, n0, _MMMu, 0, () => MultiMeasureMapping];
+var PathParameterList = [1, n0, _PPLa, 0, [() => PathParameter, 0]];
+var PipeList = [1, n0, _PL, 0, () => Pipe];
+var PlacementConstraints = [1, n0, _PC, 0, [() => PlacementConstraint, 0]];
+var PlacementStrategies = [1, n0, _PSl, 0, [() => PlacementStrategy, 0]];
+var SageMakerPipelineParameterList = [1, n0, _SMPPL, 0, [() => SageMakerPipelineParameter, 0]];
+var SecurityGroupIds = [1, n0, _SGIe, 0, [() => SecurityGroupId, 0]];
+var SecurityGroups = [1, n0, _SGe, 0, [() => SecurityGroup, 0]];
+var SingleMeasureMappings = [1, n0, _SMM, 0, () => SingleMeasureMapping];
+var Sqls = [1, n0, _Sq, 0, [() => Sql, 0]];
+var SubnetIds = [1, n0, _SIu, 0, [() => SubnetId, 0]];
+var Subnets = [1, n0, _Sub, 0, [() => Subnet, 0]];
+var TagList = [1, n0, _TL, 0, [() => Tag, 0]];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
+var HeaderParametersMap = [2, n0, _HPM, 0, [0, 0], [() => HeaderValue, 0]];
+var QueryStringParametersMap = [2, n0, _QSPM, 0, [0, 0], [() => QueryStringValue, 0]];
+var TagMap = [2, n0, _TM, 0, [0, 0], [() => TagValue, 0]];
+var MQBrokerAccessCredentials = [3, n0, _MQBAC, 0, [_BA], [0]];
+var MSKAccessCredentials = [3, n0, _MSKAC, 0, [_SSA, _CCTA], [0, 0]];
+var SelfManagedKafkaAccessConfigurationCredentials = [
+    3,
+    n0,
+    _SMKACC,
+    0,
+    [_BA, _SSA, _SSAa, _CCTA],
+    [0, 0, 0, 0],
+];
+var CreatePipe = [
+    9,
+    n0,
+    _CPr,
+    {
+        [_h]: ["POST", "/v1/pipes/{Name}", 200],
+    },
+    () => CreatePipeRequest,
+    () => CreatePipeResponse,
+];
+var DeletePipe = [
+    9,
+    n0,
+    _DP,
+    {
+        [_h]: ["DELETE", "/v1/pipes/{Name}", 200],
+    },
+    () => DeletePipeRequest,
+    () => DeletePipeResponse,
+];
+var DescribePipe = [
+    9,
+    n0,
+    _DPe,
+    {
+        [_h]: ["GET", "/v1/pipes/{Name}", 200],
+    },
+    () => DescribePipeRequest,
+    () => DescribePipeResponse,
+];
+var ListPipes = [
+    9,
+    n0,
+    _LP,
+    {
+        [_h]: ["GET", "/v1/pipes", 200],
+    },
+    () => ListPipesRequest,
+    () => ListPipesResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var StartPipe = [
+    9,
+    n0,
+    _SPta,
+    {
+        [_h]: ["POST", "/v1/pipes/{Name}/start", 200],
+    },
+    () => StartPipeRequest,
+    () => StartPipeResponse,
+];
+var StopPipe = [
+    9,
+    n0,
+    _SPto,
+    {
+        [_h]: ["POST", "/v1/pipes/{Name}/stop", 200],
+    },
+    () => StopPipeRequest,
+    () => StopPipeResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdatePipe = [
+    9,
+    n0,
+    _UP,
+    {
+        [_h]: ["PUT", "/v1/pipes/{Name}", 200],
+    },
+    () => UpdatePipeRequest,
+    () => UpdatePipeResponse,
+];
 
 class CreatePipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "CreatePipe", {})
     .n("PipesClient", "CreatePipeCommand")
-    .f(CreatePipeRequestFilterSensitiveLog, void 0)
-    .ser(se_CreatePipeCommand)
-    .de(de_CreatePipeCommand)
+    .sc(CreatePipe)
     .build() {
 }
 
@@ -1143,16 +1593,11 @@ class DeletePipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "DeletePipe", {})
     .n("PipesClient", "DeletePipeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePipeCommand)
-    .de(de_DeletePipeCommand)
+    .sc(DeletePipe)
     .build() {
 }
 
@@ -1160,16 +1605,11 @@ class DescribePipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "DescribePipe", {})
     .n("PipesClient", "DescribePipeCommand")
-    .f(void 0, DescribePipeResponseFilterSensitiveLog)
-    .ser(se_DescribePipeCommand)
-    .de(de_DescribePipeCommand)
+    .sc(DescribePipe)
     .build() {
 }
 
@@ -1177,16 +1617,11 @@ class ListPipesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "ListPipes", {})
     .n("PipesClient", "ListPipesCommand")
-    .f(ListPipesRequestFilterSensitiveLog, ListPipesResponseFilterSensitiveLog)
-    .ser(se_ListPipesCommand)
-    .de(de_ListPipesCommand)
+    .sc(ListPipes)
     .build() {
 }
 
@@ -1194,16 +1629,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "ListTagsForResource", {})
     .n("PipesClient", "ListTagsForResourceCommand")
-    .f(void 0, ListTagsForResourceResponseFilterSensitiveLog)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1211,16 +1641,11 @@ class StartPipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "StartPipe", {})
     .n("PipesClient", "StartPipeCommand")
-    .f(void 0, void 0)
-    .ser(se_StartPipeCommand)
-    .de(de_StartPipeCommand)
+    .sc(StartPipe)
     .build() {
 }
 
@@ -1228,16 +1653,11 @@ class StopPipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "StopPipe", {})
     .n("PipesClient", "StopPipeCommand")
-    .f(void 0, void 0)
-    .ser(se_StopPipeCommand)
-    .de(de_StopPipeCommand)
+    .sc(StopPipe)
     .build() {
 }
 
@@ -1245,16 +1665,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "TagResource", {})
     .n("PipesClient", "TagResourceCommand")
-    .f(TagResourceRequestFilterSensitiveLog, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1262,16 +1677,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "UntagResource", {})
     .n("PipesClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1279,16 +1689,11 @@ class UpdatePipeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Pipes", "UpdatePipe", {})
     .n("PipesClient", "UpdatePipeCommand")
-    .f(UpdatePipeRequestFilterSensitiveLog, void 0)
-    .ser(se_UpdatePipeCommand)
-    .de(de_UpdatePipeCommand)
+    .sc(UpdatePipe)
     .build() {
 }
 
@@ -1319,81 +1724,47 @@ Object.defineProperty(exports, "__Client", {
     get: function () { return smithyClient.Client; }
 });
 exports.AssignPublicIp = AssignPublicIp;
-exports.AwsVpcConfigurationFilterSensitiveLog = AwsVpcConfigurationFilterSensitiveLog;
 exports.BatchJobDependencyType = BatchJobDependencyType;
 exports.BatchResourceRequirementType = BatchResourceRequirementType;
-exports.CapacityProviderStrategyItemFilterSensitiveLog = CapacityProviderStrategyItemFilterSensitiveLog;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreatePipeCommand = CreatePipeCommand;
-exports.CreatePipeRequestFilterSensitiveLog = CreatePipeRequestFilterSensitiveLog;
 exports.DeletePipeCommand = DeletePipeCommand;
 exports.DescribePipeCommand = DescribePipeCommand;
-exports.DescribePipeResponseFilterSensitiveLog = DescribePipeResponseFilterSensitiveLog;
 exports.DimensionValueType = DimensionValueType;
 exports.DynamoDBStreamStartPosition = DynamoDBStreamStartPosition;
 exports.EcsEnvironmentFileType = EcsEnvironmentFileType;
 exports.EcsResourceRequirementType = EcsResourceRequirementType;
 exports.EpochTimeUnit = EpochTimeUnit;
-exports.FilterCriteriaFilterSensitiveLog = FilterCriteriaFilterSensitiveLog;
-exports.FilterFilterSensitiveLog = FilterFilterSensitiveLog;
 exports.IncludeExecutionDataOption = IncludeExecutionDataOption;
-exports.InternalException = InternalException;
+exports.InternalException = InternalException$1;
 exports.KinesisStreamStartPosition = KinesisStreamStartPosition;
 exports.LaunchType = LaunchType;
 exports.ListPipesCommand = ListPipesCommand;
-exports.ListPipesRequestFilterSensitiveLog = ListPipesRequestFilterSensitiveLog;
-exports.ListPipesResponseFilterSensitiveLog = ListPipesResponseFilterSensitiveLog;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.ListTagsForResourceResponseFilterSensitiveLog = ListTagsForResourceResponseFilterSensitiveLog;
 exports.LogLevel = LogLevel;
 exports.MSKStartPosition = MSKStartPosition;
 exports.MeasureValueType = MeasureValueType;
-exports.NetworkConfigurationFilterSensitiveLog = NetworkConfigurationFilterSensitiveLog;
-exports.NotFoundException = NotFoundException;
+exports.NotFoundException = NotFoundException$1;
 exports.OnPartialBatchItemFailureStreams = OnPartialBatchItemFailureStreams;
-exports.PipeEnrichmentHttpParametersFilterSensitiveLog = PipeEnrichmentHttpParametersFilterSensitiveLog;
-exports.PipeEnrichmentParametersFilterSensitiveLog = PipeEnrichmentParametersFilterSensitiveLog;
-exports.PipeSourceActiveMQBrokerParametersFilterSensitiveLog = PipeSourceActiveMQBrokerParametersFilterSensitiveLog;
-exports.PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog = PipeSourceManagedStreamingKafkaParametersFilterSensitiveLog;
-exports.PipeSourceParametersFilterSensitiveLog = PipeSourceParametersFilterSensitiveLog;
-exports.PipeSourceRabbitMQBrokerParametersFilterSensitiveLog = PipeSourceRabbitMQBrokerParametersFilterSensitiveLog;
-exports.PipeSourceSelfManagedKafkaParametersFilterSensitiveLog = PipeSourceSelfManagedKafkaParametersFilterSensitiveLog;
 exports.PipeState = PipeState;
-exports.PipeTargetEcsTaskParametersFilterSensitiveLog = PipeTargetEcsTaskParametersFilterSensitiveLog;
-exports.PipeTargetEventBridgeEventBusParametersFilterSensitiveLog = PipeTargetEventBridgeEventBusParametersFilterSensitiveLog;
-exports.PipeTargetHttpParametersFilterSensitiveLog = PipeTargetHttpParametersFilterSensitiveLog;
 exports.PipeTargetInvocationType = PipeTargetInvocationType;
-exports.PipeTargetKinesisStreamParametersFilterSensitiveLog = PipeTargetKinesisStreamParametersFilterSensitiveLog;
-exports.PipeTargetParametersFilterSensitiveLog = PipeTargetParametersFilterSensitiveLog;
-exports.PipeTargetRedshiftDataParametersFilterSensitiveLog = PipeTargetRedshiftDataParametersFilterSensitiveLog;
-exports.PipeTargetSageMakerPipelineParametersFilterSensitiveLog = PipeTargetSageMakerPipelineParametersFilterSensitiveLog;
-exports.PipeTargetSqsQueueParametersFilterSensitiveLog = PipeTargetSqsQueueParametersFilterSensitiveLog;
 exports.Pipes = Pipes;
 exports.PipesClient = PipesClient;
-exports.PipesServiceException = PipesServiceException;
-exports.PlacementConstraintFilterSensitiveLog = PlacementConstraintFilterSensitiveLog;
+exports.PipesServiceException = PipesServiceException$1;
 exports.PlacementConstraintType = PlacementConstraintType;
-exports.PlacementStrategyFilterSensitiveLog = PlacementStrategyFilterSensitiveLog;
 exports.PlacementStrategyType = PlacementStrategyType;
 exports.PropagateTags = PropagateTags;
 exports.RequestedPipeState = RequestedPipeState;
 exports.RequestedPipeStateDescribeResponse = RequestedPipeStateDescribeResponse;
 exports.S3OutputFormat = S3OutputFormat;
-exports.SageMakerPipelineParameterFilterSensitiveLog = SageMakerPipelineParameterFilterSensitiveLog;
-exports.SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog = SelfManagedKafkaAccessConfigurationVpcFilterSensitiveLog;
 exports.SelfManagedKafkaStartPosition = SelfManagedKafkaStartPosition;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartPipeCommand = StartPipeCommand;
 exports.StopPipeCommand = StopPipeCommand;
-exports.TagFilterSensitiveLog = TagFilterSensitiveLog;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TagResourceRequestFilterSensitiveLog = TagResourceRequestFilterSensitiveLog;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TimeFieldType = TimeFieldType;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdatePipeCommand = UpdatePipeCommand;
-exports.UpdatePipeRequestFilterSensitiveLog = UpdatePipeRequestFilterSensitiveLog;
-exports.UpdatePipeSourceParametersFilterSensitiveLog = UpdatePipeSourceParametersFilterSensitiveLog;
-exports.UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog = UpdatePipeSourceSelfManagedKafkaParametersFilterSensitiveLog;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListPipes = paginateListPipes;