@aws-sdk/client-codestar-notifications 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,9 +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');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class CodestarNotificationsClient 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));
@@ -111,14 +110,14 @@ class CodestarNotificationsClient extends smithyClient.Client {
     }
 }
 
-class CodestarNotificationsServiceException extends smithyClient.ServiceException {
+let CodestarNotificationsServiceException$1 = class CodestarNotificationsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, CodestarNotificationsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends CodestarNotificationsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends CodestarNotificationsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -131,8 +130,8 @@ class AccessDeniedException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
-class ConcurrentModificationException extends CodestarNotificationsServiceException {
+};
+let ConcurrentModificationException$1 = class ConcurrentModificationException extends CodestarNotificationsServiceException$1 {
     name = "ConcurrentModificationException";
     $fault = "client";
     Message;
@@ -145,8 +144,8 @@ class ConcurrentModificationException extends CodestarNotificationsServiceExcept
         Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
         this.Message = opts.Message;
     }
-}
-class ConfigurationException extends CodestarNotificationsServiceException {
+};
+let ConfigurationException$1 = class ConfigurationException extends CodestarNotificationsServiceException$1 {
     name = "ConfigurationException";
     $fault = "client";
     Message;
@@ -159,7 +158,7 @@ class ConfigurationException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, ConfigurationException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const DetailType = {
     BASIC: "BASIC",
     FULL: "FULL",
@@ -168,7 +167,7 @@ const NotificationRuleStatus = {
     DISABLED: "DISABLED",
     ENABLED: "ENABLED",
 };
-class LimitExceededException extends CodestarNotificationsServiceException {
+let LimitExceededException$1 = class LimitExceededException extends CodestarNotificationsServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     Message;
@@ -181,8 +180,8 @@ class LimitExceededException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, LimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceAlreadyExistsException extends CodestarNotificationsServiceException {
+};
+let ResourceAlreadyExistsException$1 = class ResourceAlreadyExistsException extends CodestarNotificationsServiceException$1 {
     name = "ResourceAlreadyExistsException";
     $fault = "client";
     Message;
@@ -195,8 +194,8 @@ class ResourceAlreadyExistsException extends CodestarNotificationsServiceExcepti
         Object.setPrototypeOf(this, ResourceAlreadyExistsException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends CodestarNotificationsServiceException {
+};
+let ValidationException$1 = class ValidationException extends CodestarNotificationsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -209,7 +208,7 @@ class ValidationException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const TargetStatus = {
     ACTIVE: "ACTIVE",
     DEACTIVATED: "DEACTIVATED",
@@ -217,7 +216,7 @@ const TargetStatus = {
     PENDING: "PENDING",
     UNREACHABLE: "UNREACHABLE",
 };
-class ResourceNotFoundException extends CodestarNotificationsServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends CodestarNotificationsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -230,8 +229,8 @@ class ResourceNotFoundException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidNextTokenException extends CodestarNotificationsServiceException {
+};
+let InvalidNextTokenException$1 = class InvalidNextTokenException extends CodestarNotificationsServiceException$1 {
     name = "InvalidNextTokenException";
     $fault = "client";
     Message;
@@ -244,7 +243,7 @@ class InvalidNextTokenException extends CodestarNotificationsServiceException {
         Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ListEventTypesFilterName = {
     RESOURCE_TYPE: "RESOURCE_TYPE",
     SERVICE_NAME: "SERVICE_NAME",
@@ -260,588 +259,456 @@ const ListTargetsFilterName = {
     TARGET_STATUS: "TARGET_STATUS",
     TARGET_TYPE: "TARGET_TYPE",
 };
-const TargetFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TargetAddress && { TargetAddress: smithyClient.SENSITIVE_STRING }),
-});
-const CreateNotificationRuleRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Targets && { Targets: obj.Targets.map((item) => TargetFilterSensitiveLog(item)) }),
-});
-const DeleteTargetRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TargetAddress && { TargetAddress: smithyClient.SENSITIVE_STRING }),
-});
-const TargetSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TargetAddress && { TargetAddress: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeNotificationRuleResultFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Targets && { Targets: obj.Targets.map((item) => TargetSummaryFilterSensitiveLog(item)) }),
-});
-const ListTargetsResultFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Targets && { Targets: obj.Targets.map((item) => TargetSummaryFilterSensitiveLog(item)) }),
-});
-const SubscribeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Target && { Target: TargetFilterSensitiveLog(obj.Target) }),
-});
-const UnsubscribeRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TargetAddress && { TargetAddress: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateNotificationRuleRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Name && { Name: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Targets && { Targets: obj.Targets.map((item) => TargetFilterSensitiveLog(item)) }),
-});
 
-const se_CreateNotificationRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/createNotificationRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientRequestToken: [true, (_) => _ ?? uuid.v4()],
-        DetailType: [],
-        EventTypeIds: (_) => smithyClient._json(_),
-        Name: [],
-        Resource: [],
-        Status: [],
-        Tags: (_) => smithyClient._json(_),
-        Targets: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteNotificationRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/deleteNotificationRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteTargetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/deleteTarget");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ForceUnsubscribeAll: [],
-        TargetAddress: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeNotificationRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/describeNotificationRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListEventTypesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listEventTypes");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Filters: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListNotificationRulesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listNotificationRules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Filters: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTargetsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/listTargets");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Filters: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SubscribeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/subscribe");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        ClientRequestToken: [],
-        Target: (_) => smithyClient._json(_),
-    }));
-    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("/tagResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UnsubscribeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/unsubscribe");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        TargetAddress: [],
-    }));
-    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("/untagResource/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
-    });
-    let body;
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateNotificationRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateNotificationRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        DetailType: [],
-        EventTypeIds: (_) => smithyClient._json(_),
-        Name: [],
-        Status: [],
-        Targets: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateNotificationRuleCommand = 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,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteNotificationRuleCommand = 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,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteTargetCommand = 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_DescribeNotificationRuleCommand = 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,
-        CreatedBy: smithyClient.expectString,
-        CreatedTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DetailType: smithyClient.expectString,
-        EventTypes: smithyClient._json,
-        LastModifiedTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        Resource: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-        Targets: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEventTypesCommand = 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, {
-        EventTypes: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListNotificationRulesCommand = 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,
-        NotificationRules: smithyClient._json,
-    });
-    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_ListTargetsCommand = 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,
-        Targets: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SubscribeCommand = 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,
-    });
-    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),
-    });
-    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_UnsubscribeCommand = 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,
-    });
-    Object.assign(contents, doc);
-    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_UpdateNotificationRuleCommand = 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_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.codestarnotifications#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.codestarnotifications#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
-        case "ConfigurationException":
-        case "com.amazonaws.codestarnotifications#ConfigurationException":
-            throw await de_ConfigurationExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.codestarnotifications#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ResourceAlreadyExistsException":
-        case "com.amazonaws.codestarnotifications#ResourceAlreadyExistsException":
-            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.codestarnotifications#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.codestarnotifications#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.codestarnotifications#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(CodestarNotificationsServiceException);
-const de_AccessDeniedExceptionRes = 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 AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConcurrentModificationExceptionRes = 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 ConcurrentModificationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConfigurationExceptionRes = 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 ConfigurationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidNextTokenExceptionRes = 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 InvalidNextTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_LimitExceededExceptionRes = 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 LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceAlreadyExistsExceptionRes = 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 ResourceAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = 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 ResourceNotFoundException({
-        $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, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-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 = "Arn";
+const _ADE = "AccessDeniedException";
+const _CB = "CreatedBy";
+const _CE = "ConfigurationException";
+const _CME = "ConcurrentModificationException";
+const _CNR = "CreateNotificationRule";
+const _CNRR = "CreateNotificationRuleRequest";
+const _CNRRr = "CreateNotificationRuleResult";
+const _CRT = "ClientRequestToken";
+const _CT = "CreatedTimestamp";
+const _DNR = "DeleteNotificationRule";
+const _DNRR = "DeleteNotificationRuleRequest";
+const _DNRRe = "DeleteNotificationRuleResult";
+const _DNRRes = "DescribeNotificationRuleRequest";
+const _DNRResc = "DescribeNotificationRuleResult";
+const _DNRe = "DescribeNotificationRule";
+const _DT = "DetailType";
+const _DTR = "DeleteTargetRequest";
+const _DTRe = "DeleteTargetResult";
+const _DTe = "DeleteTarget";
+const _ET = "EventTypes";
+const _ETB = "EventTypeBatch";
+const _ETI = "EventTypeIds";
+const _ETIv = "EventTypeId";
+const _ETN = "EventTypeName";
+const _ETS = "EventTypeSummary";
+const _F = "Filters";
+const _FUA = "ForceUnsubscribeAll";
+const _I = "Id";
+const _INTE = "InvalidNextTokenException";
+const _LEE = "LimitExceededException";
+const _LET = "ListEventTypes";
+const _LETF = "ListEventTypesFilter";
+const _LETFi = "ListEventTypesFilters";
+const _LETR = "ListEventTypesRequest";
+const _LETRi = "ListEventTypesResult";
+const _LMT = "LastModifiedTimestamp";
+const _LNR = "ListNotificationRules";
+const _LNRF = "ListNotificationRulesFilter";
+const _LNRFi = "ListNotificationRulesFilters";
+const _LNRR = "ListNotificationRulesRequest";
+const _LNRRi = "ListNotificationRulesResult";
+const _LT = "ListTargets";
+const _LTF = "ListTargetsFilter";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResult";
+const _LTFi = "ListTargetsFilters";
+const _LTR = "ListTargetsRequest";
+const _LTRi = "ListTargetsResult";
+const _M = "Message";
+const _MR = "MaxResults";
+const _N = "Name";
+const _NR = "NotificationRules";
+const _NRB = "NotificationRuleBatch";
+const _NRN = "NotificationRuleName";
+const _NRS = "NotificationRuleSummary";
+const _NT = "NextToken";
+const _R = "Resource";
+const _RAEE = "ResourceAlreadyExistsException";
+const _RNFE = "ResourceNotFoundException";
+const _RT = "ResourceType";
+const _S = "Status";
+const _SN = "ServiceName";
+const _SR = "SubscribeRequest";
+const _SRu = "SubscribeResult";
+const _Su = "Subscribe";
+const _T = "Targets";
+const _TA = "TargetAddress";
+const _TB = "TargetsBatch";
 const _TK = "TagKeys";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResult";
+const _TS = "TargetSummary";
+const _TSa = "TargetStatus";
+const _TT = "TargetType";
+const _Ta = "Tags";
+const _Tar = "Target";
+const _U = "Unsubscribe";
+const _UNR = "UpdateNotificationRule";
+const _UNRR = "UpdateNotificationRuleRequest";
+const _UNRRp = "UpdateNotificationRuleResult";
+const _UR = "UnsubscribeRequest";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResult";
+const _URn = "UnsubscribeResult";
+const _URnt = "UntagResource";
+const _V = "Value";
+const _VE = "ValidationException";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.codestarnotifications";
 const _tK = "tagKeys";
+const n0 = "com.amazonaws.codestarnotifications";
+var NotificationRuleName = [0, n0, _NRN, 8, 0];
+var TargetAddress = [0, n0, _TA, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ConcurrentModificationException = [
+    -3,
+    n0,
+    _CME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConcurrentModificationException, ConcurrentModificationException$1);
+var ConfigurationException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConfigurationException, ConfigurationException$1);
+var CreateNotificationRuleRequest = [
+    3,
+    n0,
+    _CNRR,
+    0,
+    [_N, _ETI, _R, _T, _DT, _CRT, _Ta, _S],
+    [[() => NotificationRuleName, 0], 64 | 0, 0, [() => Targets, 0], 0, [0, 4], 128 | 0, 0],
+];
+var CreateNotificationRuleResult = [3, n0, _CNRRr, 0, [_A], [0]];
+var DeleteNotificationRuleRequest = [3, n0, _DNRR, 0, [_A], [0]];
+var DeleteNotificationRuleResult = [3, n0, _DNRRe, 0, [_A], [0]];
+var DeleteTargetRequest = [3, n0, _DTR, 0, [_TA, _FUA], [[() => TargetAddress, 0], 2]];
+var DeleteTargetResult = [3, n0, _DTRe, 0, [], []];
+var DescribeNotificationRuleRequest = [3, n0, _DNRRes, 0, [_A], [0]];
+var DescribeNotificationRuleResult = [
+    3,
+    n0,
+    _DNRResc,
+    0,
+    [_A, _N, _ET, _R, _T, _DT, _CB, _S, _CT, _LMT, _Ta],
+    [0, [() => NotificationRuleName, 0], () => EventTypeBatch, 0, [() => TargetsBatch, 0], 0, 0, 0, 4, 4, 128 | 0],
+];
+var EventTypeSummary = [3, n0, _ETS, 0, [_ETIv, _SN, _ETN, _RT], [0, 0, 0, 0]];
+var InvalidNextTokenException = [
+    -3,
+    n0,
+    _INTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidNextTokenException, InvalidNextTokenException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListEventTypesFilter = [3, n0, _LETF, 0, [_N, _V], [0, 0]];
+var ListEventTypesRequest = [
+    3,
+    n0,
+    _LETR,
+    0,
+    [_F, _NT, _MR],
+    [() => ListEventTypesFilters, 0, 1],
+];
+var ListEventTypesResult = [3, n0, _LETRi, 0, [_ET, _NT], [() => EventTypeBatch, 0]];
+var ListNotificationRulesFilter = [3, n0, _LNRF, 0, [_N, _V], [0, 0]];
+var ListNotificationRulesRequest = [
+    3,
+    n0,
+    _LNRR,
+    0,
+    [_F, _NT, _MR],
+    [() => ListNotificationRulesFilters, 0, 1],
+];
+var ListNotificationRulesResult = [
+    3,
+    n0,
+    _LNRRi,
+    0,
+    [_NT, _NR],
+    [0, () => NotificationRuleBatch],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_A], [0]];
+var ListTagsForResourceResult = [3, n0, _LTFRRi, 0, [_Ta], [128 | 0]];
+var ListTargetsFilter = [3, n0, _LTF, 0, [_N, _V], [0, 0]];
+var ListTargetsRequest = [
+    3,
+    n0,
+    _LTR,
+    0,
+    [_F, _NT, _MR],
+    [() => ListTargetsFilters, 0, 1],
+];
+var ListTargetsResult = [3, n0, _LTRi, 0, [_T, _NT], [[() => TargetsBatch, 0], 0]];
+var NotificationRuleSummary = [3, n0, _NRS, 0, [_I, _A], [0, 0]];
+var ResourceAlreadyExistsException = [
+    -3,
+    n0,
+    _RAEE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceAlreadyExistsException, ResourceAlreadyExistsException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SubscribeRequest = [3, n0, _SR, 0, [_A, _Tar, _CRT], [0, [() => Target, 0], 0]];
+var SubscribeResult = [3, n0, _SRu, 0, [_A], [0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_A, _Ta], [0, 128 | 0]];
+var TagResourceResult = [3, n0, _TRRa, 0, [_Ta], [128 | 0]];
+var Target = [3, n0, _Tar, 0, [_TT, _TA], [0, [() => TargetAddress, 0]]];
+var TargetSummary = [3, n0, _TS, 0, [_TA, _TT, _TSa], [[() => TargetAddress, 0], 0, 0]];
+var UnsubscribeRequest = [3, n0, _UR, 0, [_A, _TA], [0, [() => TargetAddress, 0]]];
+var UnsubscribeResult = [3, n0, _URn, 0, [_A], [0]];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_A, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResult = [3, n0, _URRn, 0, [], []];
+var UpdateNotificationRuleRequest = [
+    3,
+    n0,
+    _UNRR,
+    0,
+    [_A, _N, _S, _ETI, _T, _DT],
+    [0, [() => NotificationRuleName, 0], 0, 64 | 0, [() => Targets, 0], 0],
+];
+var UpdateNotificationRuleResult = [3, n0, _UNRRp, 0, [], []];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var CodestarNotificationsServiceException = [
+    -3,
+    _s,
+    "CodestarNotificationsServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_s).registerError(CodestarNotificationsServiceException, CodestarNotificationsServiceException$1);
+var EventTypeBatch = [1, n0, _ETB, 0, () => EventTypeSummary];
+var ListEventTypesFilters = [1, n0, _LETFi, 0, () => ListEventTypesFilter];
+var ListNotificationRulesFilters = [1, n0, _LNRFi, 0, () => ListNotificationRulesFilter];
+var ListTargetsFilters = [1, n0, _LTFi, 0, () => ListTargetsFilter];
+var NotificationRuleBatch = [1, n0, _NRB, 0, () => NotificationRuleSummary];
+var Targets = [1, n0, _T, 0, [() => Target, 0]];
+var TargetsBatch = [1, n0, _TB, 0, [() => TargetSummary, 0]];
+var CreateNotificationRule = [
+    9,
+    n0,
+    _CNR,
+    {
+        [_h]: ["POST", "/createNotificationRule", 200],
+    },
+    () => CreateNotificationRuleRequest,
+    () => CreateNotificationRuleResult,
+];
+var DeleteNotificationRule = [
+    9,
+    n0,
+    _DNR,
+    {
+        [_h]: ["POST", "/deleteNotificationRule", 200],
+    },
+    () => DeleteNotificationRuleRequest,
+    () => DeleteNotificationRuleResult,
+];
+var DeleteTarget = [
+    9,
+    n0,
+    _DTe,
+    {
+        [_h]: ["POST", "/deleteTarget", 200],
+    },
+    () => DeleteTargetRequest,
+    () => DeleteTargetResult,
+];
+var DescribeNotificationRule = [
+    9,
+    n0,
+    _DNRe,
+    {
+        [_h]: ["POST", "/describeNotificationRule", 200],
+    },
+    () => DescribeNotificationRuleRequest,
+    () => DescribeNotificationRuleResult,
+];
+var ListEventTypes = [
+    9,
+    n0,
+    _LET,
+    {
+        [_h]: ["POST", "/listEventTypes", 200],
+    },
+    () => ListEventTypesRequest,
+    () => ListEventTypesResult,
+];
+var ListNotificationRules = [
+    9,
+    n0,
+    _LNR,
+    {
+        [_h]: ["POST", "/listNotificationRules", 200],
+    },
+    () => ListNotificationRulesRequest,
+    () => ListNotificationRulesResult,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["POST", "/listTagsForResource", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResult,
+];
+var ListTargets = [
+    9,
+    n0,
+    _LT,
+    {
+        [_h]: ["POST", "/listTargets", 200],
+    },
+    () => ListTargetsRequest,
+    () => ListTargetsResult,
+];
+var Subscribe = [
+    9,
+    n0,
+    _Su,
+    {
+        [_h]: ["POST", "/subscribe", 200],
+    },
+    () => SubscribeRequest,
+    () => SubscribeResult,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tagResource", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResult,
+];
+var Unsubscribe = [
+    9,
+    n0,
+    _U,
+    {
+        [_h]: ["POST", "/unsubscribe", 200],
+    },
+    () => UnsubscribeRequest,
+    () => UnsubscribeResult,
+];
+var UntagResource = [
+    9,
+    n0,
+    _URnt,
+    {
+        [_h]: ["POST", "/untagResource/{Arn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResult,
+];
+var UpdateNotificationRule = [
+    9,
+    n0,
+    _UNR,
+    {
+        [_h]: ["POST", "/updateNotificationRule", 200],
+    },
+    () => UpdateNotificationRuleRequest,
+    () => UpdateNotificationRuleResult,
+];
 
 class CreateNotificationRuleCommand 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("CodeStarNotifications_20191015", "CreateNotificationRule", {})
     .n("CodestarNotificationsClient", "CreateNotificationRuleCommand")
-    .f(CreateNotificationRuleRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateNotificationRuleCommand)
-    .de(de_CreateNotificationRuleCommand)
+    .sc(CreateNotificationRule)
     .build() {
 }
 
@@ -849,16 +716,11 @@ class DeleteNotificationRuleCommand 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("CodeStarNotifications_20191015", "DeleteNotificationRule", {})
     .n("CodestarNotificationsClient", "DeleteNotificationRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteNotificationRuleCommand)
-    .de(de_DeleteNotificationRuleCommand)
+    .sc(DeleteNotificationRule)
     .build() {
 }
 
@@ -866,16 +728,11 @@ class DeleteTargetCommand 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("CodeStarNotifications_20191015", "DeleteTarget", {})
     .n("CodestarNotificationsClient", "DeleteTargetCommand")
-    .f(DeleteTargetRequestFilterSensitiveLog, void 0)
-    .ser(se_DeleteTargetCommand)
-    .de(de_DeleteTargetCommand)
+    .sc(DeleteTarget)
     .build() {
 }
 
@@ -883,16 +740,11 @@ class DescribeNotificationRuleCommand 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("CodeStarNotifications_20191015", "DescribeNotificationRule", {})
     .n("CodestarNotificationsClient", "DescribeNotificationRuleCommand")
-    .f(void 0, DescribeNotificationRuleResultFilterSensitiveLog)
-    .ser(se_DescribeNotificationRuleCommand)
-    .de(de_DescribeNotificationRuleCommand)
+    .sc(DescribeNotificationRule)
     .build() {
 }
 
@@ -900,16 +752,11 @@ class ListEventTypesCommand 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("CodeStarNotifications_20191015", "ListEventTypes", {})
     .n("CodestarNotificationsClient", "ListEventTypesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListEventTypesCommand)
-    .de(de_ListEventTypesCommand)
+    .sc(ListEventTypes)
     .build() {
 }
 
@@ -917,16 +764,11 @@ class ListNotificationRulesCommand 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("CodeStarNotifications_20191015", "ListNotificationRules", {})
     .n("CodestarNotificationsClient", "ListNotificationRulesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListNotificationRulesCommand)
-    .de(de_ListNotificationRulesCommand)
+    .sc(ListNotificationRules)
     .build() {
 }
 
@@ -934,16 +776,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("CodeStarNotifications_20191015", "ListTagsForResource", {})
     .n("CodestarNotificationsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -951,16 +788,11 @@ class ListTargetsCommand 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("CodeStarNotifications_20191015", "ListTargets", {})
     .n("CodestarNotificationsClient", "ListTargetsCommand")
-    .f(void 0, ListTargetsResultFilterSensitiveLog)
-    .ser(se_ListTargetsCommand)
-    .de(de_ListTargetsCommand)
+    .sc(ListTargets)
     .build() {
 }
 
@@ -968,16 +800,11 @@ class SubscribeCommand 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("CodeStarNotifications_20191015", "Subscribe", {})
     .n("CodestarNotificationsClient", "SubscribeCommand")
-    .f(SubscribeRequestFilterSensitiveLog, void 0)
-    .ser(se_SubscribeCommand)
-    .de(de_SubscribeCommand)
+    .sc(Subscribe)
     .build() {
 }
 
@@ -985,16 +812,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("CodeStarNotifications_20191015", "TagResource", {})
     .n("CodestarNotificationsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1002,16 +824,11 @@ class UnsubscribeCommand 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("CodeStarNotifications_20191015", "Unsubscribe", {})
     .n("CodestarNotificationsClient", "UnsubscribeCommand")
-    .f(UnsubscribeRequestFilterSensitiveLog, void 0)
-    .ser(se_UnsubscribeCommand)
-    .de(de_UnsubscribeCommand)
+    .sc(Unsubscribe)
     .build() {
 }
 
@@ -1019,16 +836,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("CodeStarNotifications_20191015", "UntagResource", {})
     .n("CodestarNotificationsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1036,16 +848,11 @@ class UpdateNotificationRuleCommand 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("CodeStarNotifications_20191015", "UpdateNotificationRule", {})
     .n("CodestarNotificationsClient", "UpdateNotificationRuleCommand")
-    .f(UpdateNotificationRuleRequestFilterSensitiveLog, void 0)
-    .ser(se_UpdateNotificationRuleCommand)
-    .de(de_UpdateNotificationRuleCommand)
+    .sc(UpdateNotificationRule)
     .build() {
 }
 
@@ -1082,22 +889,19 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.CodestarNotifications = CodestarNotifications;
 exports.CodestarNotificationsClient = CodestarNotificationsClient;
-exports.CodestarNotificationsServiceException = CodestarNotificationsServiceException;
-exports.ConcurrentModificationException = ConcurrentModificationException;
-exports.ConfigurationException = ConfigurationException;
+exports.CodestarNotificationsServiceException = CodestarNotificationsServiceException$1;
+exports.ConcurrentModificationException = ConcurrentModificationException$1;
+exports.ConfigurationException = ConfigurationException$1;
 exports.CreateNotificationRuleCommand = CreateNotificationRuleCommand;
-exports.CreateNotificationRuleRequestFilterSensitiveLog = CreateNotificationRuleRequestFilterSensitiveLog;
 exports.DeleteNotificationRuleCommand = DeleteNotificationRuleCommand;
 exports.DeleteTargetCommand = DeleteTargetCommand;
-exports.DeleteTargetRequestFilterSensitiveLog = DeleteTargetRequestFilterSensitiveLog;
 exports.DescribeNotificationRuleCommand = DescribeNotificationRuleCommand;
-exports.DescribeNotificationRuleResultFilterSensitiveLog = DescribeNotificationRuleResultFilterSensitiveLog;
 exports.DetailType = DetailType;
-exports.InvalidNextTokenException = InvalidNextTokenException;
-exports.LimitExceededException = LimitExceededException;
+exports.InvalidNextTokenException = InvalidNextTokenException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListEventTypesCommand = ListEventTypesCommand;
 exports.ListEventTypesFilterName = ListEventTypesFilterName;
 exports.ListNotificationRulesCommand = ListNotificationRulesCommand;
@@ -1105,22 +909,16 @@ exports.ListNotificationRulesFilterName = ListNotificationRulesFilterName;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListTargetsCommand = ListTargetsCommand;
 exports.ListTargetsFilterName = ListTargetsFilterName;
-exports.ListTargetsResultFilterSensitiveLog = ListTargetsResultFilterSensitiveLog;
 exports.NotificationRuleStatus = NotificationRuleStatus;
-exports.ResourceAlreadyExistsException = ResourceAlreadyExistsException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceAlreadyExistsException = ResourceAlreadyExistsException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SubscribeCommand = SubscribeCommand;
-exports.SubscribeRequestFilterSensitiveLog = SubscribeRequestFilterSensitiveLog;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TargetFilterSensitiveLog = TargetFilterSensitiveLog;
 exports.TargetStatus = TargetStatus;
-exports.TargetSummaryFilterSensitiveLog = TargetSummaryFilterSensitiveLog;
 exports.UnsubscribeCommand = UnsubscribeCommand;
-exports.UnsubscribeRequestFilterSensitiveLog = UnsubscribeRequestFilterSensitiveLog;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateNotificationRuleCommand = UpdateNotificationRuleCommand;
-exports.UpdateNotificationRuleRequestFilterSensitiveLog = UpdateNotificationRuleRequestFilterSensitiveLog;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListEventTypes = paginateListEventTypes;
 exports.paginateListNotificationRules = paginateListNotificationRules;
 exports.paginateListTargets = paginateListTargets;