@aws-sdk/client-application-signals 3.927.0 → 3.929.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, {
@@ -89,6 +88,7 @@ class ApplicationSignalsClient 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));
@@ -108,14 +108,14 @@ class ApplicationSignalsClient extends smithyClient.Client {
     }
 }
 
-class ApplicationSignalsServiceException extends smithyClient.ServiceException {
+let ApplicationSignalsServiceException$1 = class ApplicationSignalsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ApplicationSignalsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends ApplicationSignalsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends ApplicationSignalsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -128,7 +128,7 @@ class AccessDeniedException extends ApplicationSignalsServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ServiceLevelObjectiveBudgetStatus = {
     BREACHED: "BREACHED",
     INSUFFICIENT_DATA: "INSUFFICIENT_DATA",
@@ -204,7 +204,7 @@ exports.MonitoredRequestCountMetricDataQueries = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.MonitoredRequestCountMetricDataQueries || (exports.MonitoredRequestCountMetricDataQueries = {}));
-class ThrottlingException extends ApplicationSignalsServiceException {
+let ThrottlingException$1 = class ThrottlingException extends ApplicationSignalsServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     Message;
@@ -217,8 +217,8 @@ class ThrottlingException extends ApplicationSignalsServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends ApplicationSignalsServiceException {
+};
+let ValidationException$1 = class ValidationException extends ApplicationSignalsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -229,8 +229,8 @@ class ValidationException extends ApplicationSignalsServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
-class ResourceNotFoundException extends ApplicationSignalsServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends ApplicationSignalsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     ResourceType;
@@ -247,7 +247,7 @@ class ResourceNotFoundException extends ApplicationSignalsServiceException {
         this.ResourceId = opts.ResourceId;
         this.Message = opts.Message;
     }
-}
+};
 exports.AuditTargetEntity = void 0;
 (function (AuditTargetEntity) {
     AuditTargetEntity.visit = (value, visitor) => {
@@ -276,7 +276,7 @@ const ConnectionType = {
 const ChangeEventType = {
     DEPLOYMENT: "DEPLOYMENT",
 };
-class ConflictException extends ApplicationSignalsServiceException {
+let ConflictException$1 = class ConflictException extends ApplicationSignalsServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -289,13 +289,13 @@ class ConflictException extends ApplicationSignalsServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const MetricSourceType = {
     CLOUDWATCH_METRIC: "CloudWatchMetric",
     SERVICE_DEPENDENCY: "ServiceDependency",
     SERVICE_OPERATION: "ServiceOperation",
 };
-class ServiceQuotaExceededException extends ApplicationSignalsServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends ApplicationSignalsServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -308,1067 +308,1376 @@ class ServiceQuotaExceededException extends ApplicationSignalsServiceException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-
-const se_BatchGetServiceLevelObjectiveBudgetReportCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/budget-report");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        SloIds: (_) => smithyClient._json(_),
-        Timestamp: (_) => _.getTime() / 1_000,
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchUpdateExclusionWindowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/exclusion-windows");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AddExclusionWindows: (_) => se_ExclusionWindows(_),
-        RemoveExclusionWindows: (_) => se_ExclusionWindows(_),
-        SloIds: (_) => smithyClient._json(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_CreateServiceLevelObjectiveCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/slo");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        BurnRateConfigurations: (_) => smithyClient._json(_),
-        Description: [],
-        Goal: (_) => se_Goal(_),
-        Name: [],
-        RequestBasedSliConfig: (_) => se_RequestBasedServiceLevelIndicatorConfig(_),
-        SliConfig: (_) => se_ServiceLevelIndicatorConfig(_),
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteGroupingConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/grouping-configuration");
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteServiceLevelObjectiveCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/slo/{Id}");
-    b.p("Id", () => input.Id, "{Id}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GetServiceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/service");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        KeyAttributes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetServiceLevelObjectiveCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/slo/{Id}");
-    b.p("Id", () => input.Id, "{Id}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListAuditFindingsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/auditFindings");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AuditTargets: (_) => smithyClient._json(_),
-        Auditors: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListGroupingAttributeDefinitionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/grouping-attribute-definitions");
-    const query = smithyClient.map({
-        [_NT]: [, input[_NT]],
-    });
-    let body;
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceDependenciesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/service-dependencies");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        KeyAttributes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceDependentsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/service-dependents");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        KeyAttributes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceLevelObjectiveExclusionWindowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/slo/{Id}/exclusion-windows");
-    b.p("Id", () => input.Id, "{Id}", false);
-    const query = smithyClient.map({
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceLevelObjectivesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/slos");
-    const query = smithyClient.map({
-        [_ON]: [, input[_ON]],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-        [_ILA]: [() => input.IncludeLinkedAccounts !== void 0, () => input[_ILA].toString()],
-        [_SOAAI]: [, input[_SOAAI]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        DependencyConfig: (_) => smithyClient._json(_),
-        KeyAttributes: (_) => smithyClient._json(_),
-        MetricSourceTypes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceOperationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/service-operations");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        KeyAttributes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServicesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/services");
-    const query = smithyClient.map({
-        [_ST]: [smithyClient.expectNonNull(input.StartTime, `StartTime`) != null, () => smithyClient.serializeDateTime(input[_ST]).toString()],
-        [_ET]: [smithyClient.expectNonNull(input.EndTime, `EndTime`) != null, () => smithyClient.serializeDateTime(input[_ET]).toString()],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_NT]: [, input[_NT]],
-        [_ILA]: [() => input.IncludeLinkedAccounts !== void 0, () => input[_ILA].toString()],
-        [_AAI]: [, input[_AAI]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListServiceStatesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/service/states");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AttributeFilters: (_) => smithyClient._json(_),
-        AwsAccountId: [],
-        EndTime: (_) => _.getTime() / 1_000,
-        IncludeLinkedAccounts: [],
-        MaxResults: [],
-        NextToken: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags");
-    const query = smithyClient.map({
-        [_RA]: [, smithyClient.expectNonNull(input[_RA], `ResourceArn`)],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_PutGroupingConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/grouping-configuration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        GroupingAttributeDefinitions: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StartDiscoveryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/start-discovery");
-    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("/tag-resource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceArn: [],
-        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 = {
-        "content-type": "application/json",
-    };
-    b.bp("/untag-resource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceArn: [],
-        TagKeys: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateServiceLevelObjectiveCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/slo/{Id}");
-    b.p("Id", () => input.Id, "{Id}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        BurnRateConfigurations: (_) => smithyClient._json(_),
-        Description: [],
-        Goal: (_) => se_Goal(_),
-        RequestBasedSliConfig: (_) => se_RequestBasedServiceLevelIndicatorConfig(_),
-        SliConfig: (_) => se_ServiceLevelIndicatorConfig(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const de_BatchGetServiceLevelObjectiveBudgetReportCommand = 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, {
-        Errors: smithyClient._json,
-        Reports: (_) => de_ServiceLevelObjectiveBudgetReports(_),
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchUpdateExclusionWindowsCommand = 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, {
-        Errors: smithyClient._json,
-        SloIds: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateServiceLevelObjectiveCommand = 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, {
-        Slo: (_) => de_ServiceLevelObjective(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteGroupingConfigurationCommand = 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_DeleteServiceLevelObjectiveCommand = 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_GetServiceCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogGroupReferences: smithyClient._json,
-        Service: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetServiceLevelObjectiveCommand = 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, {
-        Slo: (_) => de_ServiceLevelObjective(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListAuditFindingsCommand = 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, {
-        AuditFindings: (_) => de_AuditFindings(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListGroupingAttributeDefinitionsCommand = 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, {
-        GroupingAttributeDefinitions: smithyClient._json,
-        NextToken: smithyClient.expectString,
-        UpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceDependenciesCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        ServiceDependencies: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceDependentsCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        ServiceDependents: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceLevelObjectiveExclusionWindowsCommand = 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, {
-        ExclusionWindows: (_) => de_ExclusionWindows(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceLevelObjectivesCommand = 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,
-        SloSummaries: (_) => de_ServiceLevelObjectiveSummaries(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceOperationsCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        ServiceOperations: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServicesCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        ServiceSummaries: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListServiceStatesCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        ServiceStates: (_) => de_ServiceStates(_),
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    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_PutGroupingConfigurationCommand = 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, {
-        GroupingConfiguration: (_) => de_GroupingConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartDiscoveryCommand = 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_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_UpdateServiceLevelObjectiveCommand = 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, {
-        Slo: (_) => de_ServiceLevelObjective(_),
-    });
-    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 "ThrottlingException":
-        case "com.amazonaws.applicationsignals#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.applicationsignals#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.applicationsignals#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "AccessDeniedException":
-        case "com.amazonaws.applicationsignals#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.applicationsignals#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.applicationsignals#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(ApplicationSignalsServiceException);
-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_ConflictExceptionRes = 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 ConflictException({
-        $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,
-        ResourceId: smithyClient.expectString,
-        ResourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $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,
-    });
-    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({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: 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, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_CalendarInterval = (input, context) => {
-    return smithyClient.take(input, {
-        Duration: [],
-        DurationUnit: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    });
-};
-const se_ExclusionWindow = (input, context) => {
-    return smithyClient.take(input, {
-        Reason: [],
-        RecurrenceRule: smithyClient._json,
-        StartTime: (_) => _.getTime() / 1_000,
-        Window: smithyClient._json,
-    });
-};
-const se_ExclusionWindows = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_ExclusionWindow(entry);
-    });
-};
-const se_Goal = (input, context) => {
-    return smithyClient.take(input, {
-        AttainmentGoal: smithyClient.serializeFloat,
-        Interval: (_) => se_Interval(_),
-        WarningThreshold: smithyClient.serializeFloat,
-    });
-};
-const se_Interval = (input, context) => {
-    return exports.Interval.visit(input, {
-        CalendarInterval: (value) => ({ CalendarInterval: se_CalendarInterval(value) }),
-        RollingInterval: (value) => ({ RollingInterval: smithyClient._json(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
 };
-const se_RequestBasedServiceLevelIndicatorConfig = (input, context) => {
-    return smithyClient.take(input, {
-        ComparisonOperator: [],
-        MetricThreshold: smithyClient.serializeFloat,
-        RequestBasedSliMetricConfig: smithyClient._json,
-    });
-};
-const se_ServiceLevelIndicatorConfig = (input, context) => {
-    return smithyClient.take(input, {
-        ComparisonOperator: [],
-        MetricThreshold: smithyClient.serializeFloat,
-        SliMetricConfig: smithyClient._json,
-    });
-};
-const de_AuditFinding = (output, context) => {
-    return smithyClient.take(output, {
-        AuditorResults: smithyClient._json,
-        DependencyGraph: (_) => de_DependencyGraph(_),
-        KeyAttributes: smithyClient._json,
-        MetricGraph: (_) => de_MetricGraph(_),
-        Operation: smithyClient.expectString,
-        Type: smithyClient.expectString,
-    });
-};
-const de_AuditFindings = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AuditFinding(entry);
-    });
-    return retVal;
-};
-const de_CalendarInterval = (output, context) => {
-    return smithyClient.take(output, {
-        Duration: smithyClient.expectInt32,
-        DurationUnit: smithyClient.expectString,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_ChangeEvent = (output, context) => {
-    return smithyClient.take(output, {
-        AccountId: smithyClient.expectString,
-        ChangeEventType: smithyClient.expectString,
-        Entity: smithyClient._json,
-        EventId: smithyClient.expectString,
-        EventName: smithyClient.expectString,
-        Region: smithyClient.expectString,
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        UserName: smithyClient.expectString,
-    });
-};
-const de_DependencyGraph = (output, context) => {
-    return smithyClient.take(output, {
-        Edges: (_) => de_Edges(_),
-        Nodes: (_) => de_Nodes(_),
-    });
-};
-const de_Edge = (output, context) => {
-    return smithyClient.take(output, {
-        ConnectionType: smithyClient.expectString,
-        DestinationNodeId: smithyClient.expectString,
-        Duration: smithyClient.limitedParseDouble,
-        SourceNodeId: smithyClient.expectString,
-    });
-};
-const de_Edges = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Edge(entry);
-    });
-    return retVal;
-};
-const de_ExclusionWindow = (output, context) => {
-    return smithyClient.take(output, {
-        Reason: smithyClient.expectString,
-        RecurrenceRule: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Window: smithyClient._json,
-    });
-};
-const de_ExclusionWindows = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ExclusionWindow(entry);
-    });
-    return retVal;
-};
-const de_Goal = (output, context) => {
-    return smithyClient.take(output, {
-        AttainmentGoal: smithyClient.limitedParseDouble,
-        Interval: (_) => de_Interval(core$1.awsExpectUnion(_)),
-        WarningThreshold: smithyClient.limitedParseDouble,
-    });
-};
-const de_GroupingConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        GroupingAttributeDefinitions: smithyClient._json,
-        UpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Interval = (output, context) => {
-    if (output.CalendarInterval != null) {
-        return {
-            CalendarInterval: de_CalendarInterval(output.CalendarInterval),
-        };
-    }
-    if (output.RollingInterval != null) {
-        return {
-            RollingInterval: smithyClient._json(output.RollingInterval),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_LatestChangeEvents = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ChangeEvent(entry);
-    });
-    return retVal;
-};
-const de_MetricGraph = (output, context) => {
-    return smithyClient.take(output, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MetricDataQueries: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Node = (output, context) => {
-    return smithyClient.take(output, {
-        Duration: smithyClient.limitedParseDouble,
-        KeyAttributes: smithyClient._json,
-        Name: smithyClient.expectString,
-        NodeId: smithyClient.expectString,
-        Operation: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Type: smithyClient.expectString,
-    });
-};
-const de_Nodes = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Node(entry);
-    });
-    return retVal;
-};
-const de_RequestBasedServiceLevelIndicator = (output, context) => {
-    return smithyClient.take(output, {
-        ComparisonOperator: smithyClient.expectString,
-        MetricThreshold: smithyClient.limitedParseDouble,
-        RequestBasedSliMetric: smithyClient._json,
-    });
-};
-const de_ServiceLevelIndicator = (output, context) => {
-    return smithyClient.take(output, {
-        ComparisonOperator: smithyClient.expectString,
-        MetricThreshold: smithyClient.limitedParseDouble,
-        SliMetric: smithyClient._json,
-    });
-};
-const de_ServiceLevelObjective = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        BurnRateConfigurations: smithyClient._json,
-        CreatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Description: smithyClient.expectString,
-        EvaluationType: smithyClient.expectString,
-        Goal: (_) => de_Goal(_),
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MetricSourceType: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        RequestBasedSli: (_) => de_RequestBasedServiceLevelIndicator(_),
-        Sli: (_) => de_ServiceLevelIndicator(_),
-    });
-};
-const de_ServiceLevelObjectiveBudgetReport = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        Attainment: smithyClient.limitedParseDouble,
-        BudgetRequestsRemaining: smithyClient.expectInt32,
-        BudgetSecondsRemaining: smithyClient.expectInt32,
-        BudgetStatus: smithyClient.expectString,
-        EvaluationType: smithyClient.expectString,
-        Goal: (_) => de_Goal(_),
-        Name: smithyClient.expectString,
-        RequestBasedSli: (_) => de_RequestBasedServiceLevelIndicator(_),
-        Sli: (_) => de_ServiceLevelIndicator(_),
-        TotalBudgetRequests: smithyClient.expectInt32,
-        TotalBudgetSeconds: smithyClient.expectInt32,
-    });
-};
-const de_ServiceLevelObjectiveBudgetReports = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ServiceLevelObjectiveBudgetReport(entry);
-    });
-    return retVal;
-};
-const de_ServiceLevelObjectiveSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ServiceLevelObjectiveSummary(entry);
-    });
-    return retVal;
-};
-const de_ServiceLevelObjectiveSummary = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DependencyConfig: smithyClient._json,
-        EvaluationType: smithyClient.expectString,
-        KeyAttributes: smithyClient._json,
-        MetricSourceType: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        OperationName: smithyClient.expectString,
-    });
-};
-const de_ServiceState = (output, context) => {
-    return smithyClient.take(output, {
-        AttributeFilters: smithyClient._json,
-        LatestChangeEvents: (_) => de_LatestChangeEvents(_),
-        Service: smithyClient._json,
-    });
-};
-const de_ServiceStates = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ServiceState(entry);
-    });
-    return retVal;
-};
-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 = "Auditor";
 const _AAI = "AwsAccountId";
+const _ADE = "AccessDeniedException";
+const _AEW = "AddExclusionWindows";
+const _AF = "AttributeFilter";
+const _AFN = "AttributeFilterName";
+const _AFV = "AttributeFilterValues";
+const _AFt = "AttributeFilters";
+const _AFu = "AuditFinding";
+const _AFud = "AuditFindings";
+const _AG = "AttainmentGoal";
+const _AI = "AccountId";
+const _AM = "AttributeMaps";
+const _AR = "AuditorResults";
+const _ARu = "AuditorResult";
+const _AT = "AuditTarget";
+const _ATE = "AuditTargetEntity";
+const _ATu = "AuditTargets";
+const _Ar = "Arn";
+const _At = "Attainment";
+const _Au = "Auditors";
+const _BCM = "BadCountMetric";
+const _BGSLOBR = "BatchGetServiceLevelObjectiveBudgetReport";
+const _BGSLOBRI = "BatchGetServiceLevelObjectiveBudgetReportInput";
+const _BGSLOBRO = "BatchGetServiceLevelObjectiveBudgetReportOutput";
+const _BRC = "BurnRateConfiguration";
+const _BRCu = "BurnRateConfigurations";
+const _BRR = "BudgetRequestsRemaining";
+const _BS = "BudgetStatus";
+const _BSR = "BudgetSecondsRemaining";
+const _BUEW = "BatchUpdateExclusionWindows";
+const _BUEWE = "BatchUpdateExclusionWindowsError";
+const _BUEWEa = "BatchUpdateExclusionWindowsErrors";
+const _BUEWI = "BatchUpdateExclusionWindowsInput";
+const _BUEWO = "BatchUpdateExclusionWindowsOutput";
+const _C = "Canary";
+const _CE = "CanaryEntity";
+const _CET = "ChangeEventType";
+const _CEh = "ChangeEvent";
+const _CEo = "ConflictException";
+const _CI = "CalendarInterval";
+const _CN = "CanaryName";
+const _CO = "ComparisonOperator";
+const _CSLO = "CreateServiceLevelObjective";
+const _CSLOI = "CreateServiceLevelObjectiveInput";
+const _CSLOO = "CreateServiceLevelObjectiveOutput";
+const _CT = "ConnectionType";
+const _CTr = "CreatedTime";
+const _D = "Description";
+const _DC = "DependencyConfig";
+const _DG = "DependencyGraph";
+const _DGC = "DeleteGroupingConfiguration";
+const _DGCO = "DeleteGroupingConfigurationOutput";
+const _DGV = "DefaultGroupingValue";
+const _DKA = "DependencyKeyAttributes";
+const _DKAe = "DependentKeyAttributes";
+const _DNI = "DestinationNodeId";
+const _DON = "DependencyOperationName";
+const _DONe = "DependentOperationName";
+const _DSLO = "DeleteServiceLevelObjective";
+const _DSLOI = "DeleteServiceLevelObjectiveInput";
+const _DSLOO = "DeleteServiceLevelObjectiveOutput";
+const _DU = "DurationUnit";
+const _Da = "Data";
+const _Di = "Dimension";
+const _Dim = "Dimensions";
+const _Du = "Duration";
+const _E = "Errors";
+const _EC = "ErrorCode";
+const _EI = "EventId";
+const _EM = "ErrorMessage";
+const _EN = "EventName";
 const _ET = "EndTime";
+const _ETv = "EvaluationType";
+const _EW = "ExclusionWindow";
+const _EWx = "ExclusionWindows";
+const _Ed = "Edges";
+const _Edg = "Edge";
+const _En = "Entity";
+const _Env = "Environment";
+const _Ex = "Expression";
+const _G = "Goal";
+const _GAD = "GroupingAttributeDefinition";
+const _GADr = "GroupingAttributeDefinitions";
+const _GC = "GroupingConfiguration";
+const _GCM = "GoodCountMetric";
+const _GI = "GroupIdentifier";
+const _GN = "GroupingName";
+const _GNr = "GroupName";
+const _GS = "GroupSource";
+const _GSI = "GetServiceInput";
+const _GSK = "GroupingSourceKeys";
+const _GSLO = "GetServiceLevelObjective";
+const _GSLOI = "GetServiceLevelObjectiveInput";
+const _GSLOO = "GetServiceLevelObjectiveOutput";
+const _GSO = "GetServiceOutput";
+const _GSe = "GetService";
+const _GV = "GroupValue";
+const _I = "Id";
 const _ILA = "IncludeLinkedAccounts";
+const _In = "Interval";
+const _K = "Key";
+const _KA = "KeyAttributes";
+const _L = "Label";
+const _LAF = "ListAuditFindings";
+const _LAFI = "ListAuditFindingsInput";
+const _LAFO = "ListAuditFindingsOutput";
+const _LBWM = "LookBackWindowMinutes";
+const _LCE = "LatestChangeEvents";
+const _LGAD = "ListGroupingAttributeDefinitions";
+const _LGADI = "ListGroupingAttributeDefinitionsInput";
+const _LGADO = "ListGroupingAttributeDefinitionsOutput";
+const _LGR = "LogGroupReferences";
+const _LS = "ListServices";
+const _LSD = "ListServiceDependencies";
+const _LSDI = "ListServiceDependenciesInput";
+const _LSDIi = "ListServiceDependentsInput";
+const _LSDO = "ListServiceDependenciesOutput";
+const _LSDOi = "ListServiceDependentsOutput";
+const _LSDi = "ListServiceDependents";
+const _LSI = "ListServicesInput";
+const _LSLO = "ListServiceLevelObjectives";
+const _LSLOEW = "ListServiceLevelObjectiveExclusionWindows";
+const _LSLOEWI = "ListServiceLevelObjectiveExclusionWindowsInput";
+const _LSLOEWO = "ListServiceLevelObjectiveExclusionWindowsOutput";
+const _LSLOI = "ListServiceLevelObjectivesInput";
+const _LSLOO = "ListServiceLevelObjectivesOutput";
+const _LSO = "ListServicesOutput";
+const _LSOI = "ListServiceOperationsInput";
+const _LSOO = "ListServiceOperationsOutput";
+const _LSOi = "ListServiceOperations";
+const _LSS = "ListServiceStates";
+const _LSSI = "ListServiceStatesInput";
+const _LSSO = "ListServiceStatesOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LUT = "LastUpdatedTime";
+const _M = "Message";
+const _MDQ = "MetricDataQuery";
+const _MDQe = "MetricDataQueries";
+const _MG = "MetricGraph";
+const _MN = "MetricName";
 const _MR = "MaxResults";
+const _MRCM = "MonitoredRequestCountMetric";
+const _MRCMDQ = "MonitoredRequestCountMetricDataQueries";
+const _MRe = "MetricReference";
+const _MRet = "MetricReferences";
+const _MS = "MetricStat";
+const _MST = "MetricSourceTypes";
+const _MSTe = "MetricSourceType";
+const _MT = "MetricType";
+const _MTe = "MetricThreshold";
+const _Me = "Metric";
+const _N = "Name";
+const _NI = "NodeId";
 const _NT = "NextToken";
+const _Na = "Namespace";
+const _No = "Nodes";
+const _Nod = "Node";
+const _O = "Operation";
 const _ON = "OperationName";
+const _P = "Period";
+const _PGC = "PutGroupingConfiguration";
+const _PGCI = "PutGroupingConfigurationInput";
+const _PGCO = "PutGroupingConfigurationOutput";
+const _PS = "PeriodSeconds";
+const _R = "Reports";
 const _RA = "ResourceArn";
+const _RBS = "RequestBasedSli";
+const _RBSC = "RequestBasedSliConfig";
+const _RBSLI = "RequestBasedServiceLevelIndicator";
+const _RBSLIC = "RequestBasedServiceLevelIndicatorConfig";
+const _RBSLIM = "RequestBasedServiceLevelIndicatorMetric";
+const _RBSLIMC = "RequestBasedServiceLevelIndicatorMetricConfig";
+const _RBSM = "RequestBasedSliMetric";
+const _RBSMC = "RequestBasedSliMetricConfig";
+const _RD = "ReturnData";
+const _REW = "RemoveExclusionWindows";
+const _RI = "ResourceId";
+const _RIo = "RollingInterval";
+const _RNFE = "ResourceNotFoundException";
+const _RR = "RecurrenceRule";
+const _RT = "ResourceType";
+const _Re = "Region";
+const _Rea = "Reason";
+const _S = "Severity";
+const _SA = "SloArn";
+const _SC = "SliConfig";
+const _SD = "ServiceDependencies";
+const _SDI = "StartDiscoveryInput";
+const _SDO = "StartDiscoveryOutput";
+const _SDe = "ServiceDependents";
+const _SDer = "ServiceDependency";
+const _SDerv = "ServiceDependent";
+const _SDt = "StartDiscovery";
+const _SE = "ServiceEntity";
+const _SG = "ServiceGroups";
+const _SGe = "ServiceGroup";
+const _SI = "SloIds";
+const _SIl = "SloId";
+const _SLI = "ServiceLevelIndicator";
+const _SLIC = "ServiceLevelIndicatorConfig";
+const _SLIM = "ServiceLevelIndicatorMetric";
+const _SLIMC = "ServiceLevelIndicatorMetricConfig";
+const _SLO = "ServiceLevelObjective";
+const _SLOBR = "ServiceLevelObjectiveBudgetReport";
+const _SLOBRE = "ServiceLevelObjectiveBudgetReportError";
+const _SLOBREe = "ServiceLevelObjectiveBudgetReportErrors";
+const _SLOBRe = "ServiceLevelObjectiveBudgetReports";
+const _SLOE = "ServiceLevelObjectiveEntity";
+const _SLOS = "ServiceLevelObjectiveSummary";
+const _SLOSe = "ServiceLevelObjectiveSummaries";
+const _SM = "SliMetric";
+const _SMC = "SliMetricConfig";
+const _SN = "SloName";
+const _SNI = "SourceNodeId";
+const _SO = "ServiceOperations";
 const _SOAAI = "SloOwnerAwsAccountId";
+const _SOE = "ServiceOperationEntity";
+const _SOe = "ServiceOperation";
+const _SQEE = "ServiceQuotaExceededException";
+const _SS = "SloSummaries";
+const _SSe = "ServiceSummaries";
+const _SSer = "ServiceStates";
+const _SServ = "ServiceState";
+const _SServi = "ServiceSummary";
 const _ST = "StartTime";
+const _Se = "Service";
+const _Sl = "Slo";
+const _Sli = "Sli";
+const _St = "Stat";
+const _Sta = "Status";
+const _Stat = "Statistic";
+const _T = "Type";
+const _TBR = "TotalBudgetRequests";
+const _TBS = "TotalBudgetSeconds";
+const _TE = "ThrottlingException";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TR = "TagResource";
+const _TRCM = "TotalRequestCountMetric";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _Ta = "Tags";
+const _Tag = "Tag";
+const _Ti = "Timestamp";
+const _U = "Unit";
+const _UA = "UpdatedAt";
+const _UN = "UserName";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _USLO = "UpdateServiceLevelObjective";
+const _USLOI = "UpdateServiceLevelObjectiveInput";
+const _USLOO = "UpdateServiceLevelObjectiveOutput";
+const _V = "Value";
+const _VE = "ValidationException";
+const _W = "Window";
+const _WT = "WarningThreshold";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _m = "message";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.applicationsignals";
+const n0 = "com.amazonaws.applicationsignals";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`AccessDenied`, 403],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AttributeFilter = [3, n0, _AF, 0, [_AFN, _AFV], [0, 64 | 0]];
+var AuditFinding = [
+    3,
+    n0,
+    _AFu,
+    0,
+    [_KA, _AR, _O, _MG, _DG, _T],
+    [128 | 0, () => AuditorResults, 0, () => MetricGraph, () => DependencyGraph, 0],
+];
+var AuditorResult = [3, n0, _ARu, 0, [_A, _D, _S], [0, 0, 0]];
+var AuditTarget = [3, n0, _AT, 0, [_T, _Da], [0, () => AuditTargetEntity]];
+var BatchGetServiceLevelObjectiveBudgetReportInput = [
+    3,
+    n0,
+    _BGSLOBRI,
+    0,
+    [_Ti, _SI],
+    [4, 64 | 0],
+];
+var BatchGetServiceLevelObjectiveBudgetReportOutput = [
+    3,
+    n0,
+    _BGSLOBRO,
+    0,
+    [_Ti, _R, _E],
+    [4, () => ServiceLevelObjectiveBudgetReports, () => ServiceLevelObjectiveBudgetReportErrors],
+];
+var BatchUpdateExclusionWindowsError = [3, n0, _BUEWE, 0, [_SIl, _EC, _EM], [0, 0, 0]];
+var BatchUpdateExclusionWindowsInput = [
+    3,
+    n0,
+    _BUEWI,
+    0,
+    [_SI, _AEW, _REW],
+    [64 | 0, () => ExclusionWindows, () => ExclusionWindows],
+];
+var BatchUpdateExclusionWindowsOutput = [
+    3,
+    n0,
+    _BUEWO,
+    0,
+    [_SI, _E],
+    [64 | 0, () => BatchUpdateExclusionWindowsErrors],
+];
+var BurnRateConfiguration = [3, n0, _BRC, 0, [_LBWM], [1]];
+var CalendarInterval = [3, n0, _CI, 0, [_ST, _DU, _Du], [4, 0, 1]];
+var CanaryEntity = [3, n0, _CE, 0, [_CN], [0]];
+var ChangeEvent = [
+    3,
+    n0,
+    _CEh,
+    0,
+    [_Ti, _AI, _Re, _En, _CET, _EI, _UN, _EN],
+    [4, 0, 0, 128 | 0, 0, 0, 0, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CEo,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateServiceLevelObjectiveInput = [
+    3,
+    n0,
+    _CSLOI,
+    0,
+    [_N, _D, _SC, _RBSC, _G, _Ta, _BRCu],
+    [
+        0,
+        0,
+        () => ServiceLevelIndicatorConfig,
+        () => RequestBasedServiceLevelIndicatorConfig,
+        () => Goal,
+        () => TagList,
+        () => BurnRateConfigurations,
+    ],
+];
+var CreateServiceLevelObjectiveOutput = [
+    3,
+    n0,
+    _CSLOO,
+    0,
+    [_Sl],
+    [() => ServiceLevelObjective],
+];
+var DeleteGroupingConfigurationOutput = [3, n0, _DGCO, 0, [], []];
+var DeleteServiceLevelObjectiveInput = [3, n0, _DSLOI, 0, [_I], [[0, 1]]];
+var DeleteServiceLevelObjectiveOutput = [3, n0, _DSLOO, 0, [], []];
+var DependencyConfig = [3, n0, _DC, 0, [_DKA, _DON], [128 | 0, 0]];
+var DependencyGraph = [3, n0, _DG, 0, [_No, _Ed], [() => Nodes, () => Edges]];
+var Dimension = [3, n0, _Di, 0, [_N, _V], [0, 0]];
+var Edge = [3, n0, _Edg, 0, [_SNI, _DNI, _Du, _CT], [0, 0, 1, 0]];
+var ExclusionWindow = [
+    3,
+    n0,
+    _EW,
+    0,
+    [_W, _ST, _RR, _Rea],
+    [() => Window, 4, () => RecurrenceRule, 0],
+];
+var GetServiceInput = [
+    3,
+    n0,
+    _GSI,
+    0,
+    [_ST, _ET, _KA],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        128 | 0,
+    ],
+];
+var GetServiceLevelObjectiveInput = [3, n0, _GSLOI, 0, [_I], [[0, 1]]];
+var GetServiceLevelObjectiveOutput = [
+    3,
+    n0,
+    _GSLOO,
+    0,
+    [_Sl],
+    [() => ServiceLevelObjective],
+];
+var GetServiceOutput = [
+    3,
+    n0,
+    _GSO,
+    0,
+    [_Se, _ST, _ET, _LGR],
+    [() => Service, 4, 4, [1, n0, _LGR, 0, 128 | 0]],
+];
+var Goal = [3, n0, _G, 0, [_In, _AG, _WT], [() => Interval, 1, 1]];
+var GroupingAttributeDefinition = [3, n0, _GAD, 0, [_GN, _GSK, _DGV], [0, 64 | 0, 0]];
+var GroupingConfiguration = [
+    3,
+    n0,
+    _GC,
+    0,
+    [_GADr, _UA],
+    [() => GroupingAttributeDefinitions, 4],
+];
+var ListAuditFindingsInput = [
+    3,
+    n0,
+    _LAFI,
+    0,
+    [_ST, _ET, _Au, _ATu, _NT, _MR],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        64 | 0,
+        () => AuditTargets,
+        0,
+        1,
+    ],
+];
+var ListAuditFindingsOutput = [3, n0, _LAFO, 0, [_AFud, _NT], [() => AuditFindings, 0]];
+var ListGroupingAttributeDefinitionsInput = [
+    3,
+    n0,
+    _LGADI,
+    0,
+    [_NT],
+    [
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+    ],
+];
+var ListGroupingAttributeDefinitionsOutput = [
+    3,
+    n0,
+    _LGADO,
+    0,
+    [_GADr, _UA, _NT],
+    [() => GroupingAttributeDefinitions, 4, 0],
+];
+var ListServiceDependenciesInput = [
+    3,
+    n0,
+    _LSDI,
+    0,
+    [_ST, _ET, _KA, _MR, _NT],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        128 | 0,
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+    ],
+];
+var ListServiceDependenciesOutput = [
+    3,
+    n0,
+    _LSDO,
+    0,
+    [_ST, _ET, _SD, _NT],
+    [4, 4, () => ServiceDependencies, 0],
+];
+var ListServiceDependentsInput = [
+    3,
+    n0,
+    _LSDIi,
+    0,
+    [_ST, _ET, _KA, _MR, _NT],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        128 | 0,
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+    ],
+];
+var ListServiceDependentsOutput = [
+    3,
+    n0,
+    _LSDOi,
+    0,
+    [_ST, _ET, _SDe, _NT],
+    [4, 4, () => ServiceDependents, 0],
+];
+var ListServiceLevelObjectiveExclusionWindowsInput = [
+    3,
+    n0,
+    _LSLOEWI,
+    0,
+    [_I, _MR, _NT],
+    [
+        [0, 1],
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+    ],
+];
+var ListServiceLevelObjectiveExclusionWindowsOutput = [
+    3,
+    n0,
+    _LSLOEWO,
+    0,
+    [_EWx, _NT],
+    [() => ExclusionWindows, 0],
+];
+var ListServiceLevelObjectivesInput = [
+    3,
+    n0,
+    _LSLOI,
+    0,
+    [_KA, _ON, _DC, _MR, _NT, _ILA, _SOAAI, _MST],
+    [
+        128 | 0,
+        [
+            0,
+            {
+                [_hQ]: _ON,
+            },
+        ],
+        () => DependencyConfig,
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            2,
+            {
+                [_hQ]: _ILA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _SOAAI,
+            },
+        ],
+        64 | 0,
+    ],
+];
+var ListServiceLevelObjectivesOutput = [
+    3,
+    n0,
+    _LSLOO,
+    0,
+    [_SS, _NT],
+    [() => ServiceLevelObjectiveSummaries, 0],
+];
+var ListServiceOperationsInput = [
+    3,
+    n0,
+    _LSOI,
+    0,
+    [_ST, _ET, _KA, _MR, _NT],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        128 | 0,
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+    ],
+];
+var ListServiceOperationsOutput = [
+    3,
+    n0,
+    _LSOO,
+    0,
+    [_ST, _ET, _SO, _NT],
+    [4, 4, () => ServiceOperations, 0],
+];
+var ListServicesInput = [
+    3,
+    n0,
+    _LSI,
+    0,
+    [_ST, _ET, _MR, _NT, _ILA, _AAI],
+    [
+        [
+            4,
+            {
+                [_hQ]: _ST,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _ET,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            2,
+            {
+                [_hQ]: _ILA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _AAI,
+            },
+        ],
+    ],
+];
+var ListServicesOutput = [
+    3,
+    n0,
+    _LSO,
+    0,
+    [_ST, _ET, _SSe, _NT],
+    [4, 4, () => ServiceSummaries, 0],
+];
+var ListServiceStatesInput = [
+    3,
+    n0,
+    _LSSI,
+    0,
+    [_ST, _ET, _MR, _NT, _ILA, _AAI, _AFt],
+    [4, 4, 1, 0, 2, 0, () => AttributeFilters],
+];
+var ListServiceStatesOutput = [
+    3,
+    n0,
+    _LSSO,
+    0,
+    [_ST, _ET, _SSer, _NT],
+    [4, 4, () => ServiceStates, 0],
+];
+var ListTagsForResourceRequest = [
+    3,
+    n0,
+    _LTFRR,
+    0,
+    [_RA],
+    [
+        [
+            0,
+            {
+                [_hQ]: _RA,
+            },
+        ],
+    ],
+];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_Ta], [() => TagList]];
+var Metric = [3, n0, _Me, 0, [_Na, _MN, _Dim], [0, 0, () => Dimensions]];
+var MetricDataQuery = [
+    3,
+    n0,
+    _MDQ,
+    0,
+    [_I, _MS, _Ex, _L, _RD, _P, _AI],
+    [0, () => MetricStat, 0, 0, 2, 1, 0],
+];
+var MetricGraph = [3, n0, _MG, 0, [_MDQe, _ST, _ET], [() => MetricDataQueries, 4, 4]];
+var MetricReference = [
+    3,
+    n0,
+    _MRe,
+    0,
+    [_Na, _MT, _Dim, _MN, _AI],
+    [0, 0, () => Dimensions, 0, 0],
+];
+var MetricStat = [3, n0, _MS, 0, [_Me, _P, _St, _U], [() => Metric, 1, 0, 0]];
+var Node = [
+    3,
+    n0,
+    _Nod,
+    0,
+    [_KA, _N, _NI, _O, _T, _Du, _Sta],
+    [128 | 0, 0, 0, 0, 0, 1, 0],
+];
+var PutGroupingConfigurationInput = [
+    3,
+    n0,
+    _PGCI,
+    0,
+    [_GADr],
+    [() => GroupingAttributeDefinitions],
+];
+var PutGroupingConfigurationOutput = [
+    3,
+    n0,
+    _PGCO,
+    0,
+    [_GC],
+    [() => GroupingConfiguration],
+];
+var RecurrenceRule = [3, n0, _RR, 0, [_Ex], [0]];
+var RequestBasedServiceLevelIndicator = [
+    3,
+    n0,
+    _RBSLI,
+    0,
+    [_RBSM, _MTe, _CO],
+    [() => RequestBasedServiceLevelIndicatorMetric, 1, 0],
+];
+var RequestBasedServiceLevelIndicatorConfig = [
+    3,
+    n0,
+    _RBSLIC,
+    0,
+    [_RBSMC, _MTe, _CO],
+    [() => RequestBasedServiceLevelIndicatorMetricConfig, 1, 0],
+];
+var RequestBasedServiceLevelIndicatorMetric = [
+    3,
+    n0,
+    _RBSLIM,
+    0,
+    [_KA, _ON, _MT, _TRCM, _MRCM, _DC],
+    [128 | 0, 0, 0, () => MetricDataQueries, () => MonitoredRequestCountMetricDataQueries, () => DependencyConfig],
+];
+var RequestBasedServiceLevelIndicatorMetricConfig = [
+    3,
+    n0,
+    _RBSLIMC,
+    0,
+    [_KA, _ON, _MT, _TRCM, _MRCM, _DC],
+    [128 | 0, 0, 0, () => MetricDataQueries, () => MonitoredRequestCountMetricDataQueries, () => DependencyConfig],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_RT, _RI, _M],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RollingInterval = [3, n0, _RIo, 0, [_DU, _Du], [0, 1]];
+var Service = [
+    3,
+    n0,
+    _Se,
+    0,
+    [_KA, _AM, _SG, _MRet, _LGR],
+    [128 | 0, [1, n0, _AM, 0, 128 | 0], () => ServiceGroups, () => MetricReferences, [1, n0, _LGR, 0, 128 | 0]],
+];
+var ServiceDependency = [
+    3,
+    n0,
+    _SDer,
+    0,
+    [_ON, _DKA, _DON, _MRet],
+    [0, 128 | 0, 0, () => MetricReferences],
+];
+var ServiceDependent = [
+    3,
+    n0,
+    _SDerv,
+    0,
+    [_ON, _DKAe, _DONe, _MRet],
+    [0, 128 | 0, 0, () => MetricReferences],
+];
+var ServiceEntity = [3, n0, _SE, 0, [_T, _N, _Env, _AAI], [0, 0, 0, 0]];
+var ServiceGroup = [3, n0, _SGe, 0, [_GNr, _GV, _GS, _GI], [0, 0, 0, 0]];
+var ServiceLevelIndicator = [
+    3,
+    n0,
+    _SLI,
+    0,
+    [_SM, _MTe, _CO],
+    [() => ServiceLevelIndicatorMetric, 1, 0],
+];
+var ServiceLevelIndicatorConfig = [
+    3,
+    n0,
+    _SLIC,
+    0,
+    [_SMC, _MTe, _CO],
+    [() => ServiceLevelIndicatorMetricConfig, 1, 0],
+];
+var ServiceLevelIndicatorMetric = [
+    3,
+    n0,
+    _SLIM,
+    0,
+    [_KA, _ON, _MT, _MDQe, _DC],
+    [128 | 0, 0, 0, () => MetricDataQueries, () => DependencyConfig],
+];
+var ServiceLevelIndicatorMetricConfig = [
+    3,
+    n0,
+    _SLIMC,
+    0,
+    [_KA, _ON, _MT, _MN, _Stat, _PS, _MDQe, _DC],
+    [128 | 0, 0, 0, 0, 0, 1, () => MetricDataQueries, () => DependencyConfig],
+];
+var ServiceLevelObjective = [
+    3,
+    n0,
+    _SLO,
+    0,
+    [_Ar, _N, _D, _CTr, _LUT, _Sli, _RBS, _ETv, _G, _BRCu, _MSTe],
+    [
+        0,
+        0,
+        0,
+        4,
+        4,
+        () => ServiceLevelIndicator,
+        () => RequestBasedServiceLevelIndicator,
+        0,
+        () => Goal,
+        () => BurnRateConfigurations,
+        0,
+    ],
+];
+var ServiceLevelObjectiveBudgetReport = [
+    3,
+    n0,
+    _SLOBR,
+    0,
+    [_Ar, _N, _ETv, _BS, _At, _TBS, _BSR, _TBR, _BRR, _Sli, _RBS, _G],
+    [0, 0, 0, 0, 1, 1, 1, 1, 1, () => ServiceLevelIndicator, () => RequestBasedServiceLevelIndicator, () => Goal],
+];
+var ServiceLevelObjectiveBudgetReportError = [
+    3,
+    n0,
+    _SLOBRE,
+    0,
+    [_N, _Ar, _EC, _EM],
+    [0, 0, 0, 0],
+];
+var ServiceLevelObjectiveEntity = [3, n0, _SLOE, 0, [_SN, _SA], [0, 0]];
+var ServiceLevelObjectiveSummary = [
+    3,
+    n0,
+    _SLOS,
+    0,
+    [_Ar, _N, _KA, _ON, _DC, _CTr, _ETv, _MSTe],
+    [0, 0, 128 | 0, 0, () => DependencyConfig, 4, 0, 0],
+];
+var ServiceOperation = [3, n0, _SOe, 0, [_N, _MRet], [0, () => MetricReferences]];
+var ServiceOperationEntity = [
+    3,
+    n0,
+    _SOE,
+    0,
+    [_Se, _O, _MT],
+    [() => ServiceEntity, 0, 0],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var ServiceState = [
+    3,
+    n0,
+    _SServ,
+    0,
+    [_AFt, _Se, _LCE],
+    [() => AttributeFilters, 128 | 0, () => LatestChangeEvents],
+];
+var ServiceSummary = [
+    3,
+    n0,
+    _SServi,
+    0,
+    [_KA, _AM, _MRet, _SG],
+    [128 | 0, [1, n0, _AM, 0, 128 | 0], () => MetricReferences, () => ServiceGroups],
+];
+var StartDiscoveryInput = [3, n0, _SDI, 0, [], []];
+var StartDiscoveryOutput = [3, n0, _SDO, 0, [], []];
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RA, _Ta], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [3, n0, _URR, 0, [_RA, _TK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateServiceLevelObjectiveInput = [
+    3,
+    n0,
+    _USLOI,
+    0,
+    [_I, _D, _SC, _RBSC, _G, _BRCu],
+    [
+        [0, 1],
+        0,
+        () => ServiceLevelIndicatorConfig,
+        () => RequestBasedServiceLevelIndicatorConfig,
+        () => Goal,
+        () => BurnRateConfigurations,
+    ],
+];
+var UpdateServiceLevelObjectiveOutput = [
+    3,
+    n0,
+    _USLOO,
+    0,
+    [_Sl],
+    [() => ServiceLevelObjective],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ValidationError`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var Window = [3, n0, _W, 0, [_DU, _Du], [0, 1]];
+var __Unit = "unit";
+var ApplicationSignalsServiceException = [
+    -3,
+    _s,
+    "ApplicationSignalsServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_s).registerError(ApplicationSignalsServiceException, ApplicationSignalsServiceException$1);
+var AttributeFilters = [1, n0, _AFt, 0, () => AttributeFilter];
+var AuditFindings = [1, n0, _AFud, 0, () => AuditFinding];
+var AuditorResults = [1, n0, _AR, 0, () => AuditorResult];
+var AuditTargets = [1, n0, _ATu, 0, () => AuditTarget];
+var BatchUpdateExclusionWindowsErrors = [
+    1,
+    n0,
+    _BUEWEa,
+    0,
+    () => BatchUpdateExclusionWindowsError,
+];
+var BurnRateConfigurations = [1, n0, _BRCu, 0, () => BurnRateConfiguration];
+var Dimensions = [1, n0, _Dim, 0, () => Dimension];
+var Edges = [1, n0, _Ed, 0, () => Edge];
+var ExclusionWindows = [1, n0, _EWx, 0, () => ExclusionWindow];
+var GroupingAttributeDefinitions = [1, n0, _GADr, 0, () => GroupingAttributeDefinition];
+var LatestChangeEvents = [1, n0, _LCE, 0, () => ChangeEvent];
+var MetricDataQueries = [1, n0, _MDQe, 0, () => MetricDataQuery];
+var MetricReferences = [1, n0, _MRet, 0, () => MetricReference];
+var Nodes = [1, n0, _No, 0, () => Node];
+var ServiceDependencies = [1, n0, _SD, 0, () => ServiceDependency];
+var ServiceDependents = [1, n0, _SDe, 0, () => ServiceDependent];
+var ServiceGroups = [1, n0, _SG, 0, () => ServiceGroup];
+var ServiceLevelObjectiveBudgetReportErrors = [
+    1,
+    n0,
+    _SLOBREe,
+    0,
+    () => ServiceLevelObjectiveBudgetReportError,
+];
+var ServiceLevelObjectiveBudgetReports = [
+    1,
+    n0,
+    _SLOBRe,
+    0,
+    () => ServiceLevelObjectiveBudgetReport,
+];
+var ServiceLevelObjectiveSummaries = [1, n0, _SLOSe, 0, () => ServiceLevelObjectiveSummary];
+var ServiceOperations = [1, n0, _SO, 0, () => ServiceOperation];
+var ServiceStates = [1, n0, _SSer, 0, () => ServiceState];
+var ServiceSummaries = [1, n0, _SSe, 0, () => ServiceSummary];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var AuditTargetEntity = [
+    3,
+    n0,
+    _ATE,
+    0,
+    [_Se, _Sl, _SOe, _C],
+    [() => ServiceEntity, () => ServiceLevelObjectiveEntity, () => ServiceOperationEntity, () => CanaryEntity],
+];
+var Interval = [
+    3,
+    n0,
+    _In,
+    0,
+    [_RIo, _CI],
+    [() => RollingInterval, () => CalendarInterval],
+];
+var MonitoredRequestCountMetricDataQueries = [
+    3,
+    n0,
+    _MRCMDQ,
+    0,
+    [_GCM, _BCM],
+    [() => MetricDataQueries, () => MetricDataQueries],
+];
+var BatchGetServiceLevelObjectiveBudgetReport = [
+    9,
+    n0,
+    _BGSLOBR,
+    {
+        [_h]: ["POST", "/budget-report", 200],
+    },
+    () => BatchGetServiceLevelObjectiveBudgetReportInput,
+    () => BatchGetServiceLevelObjectiveBudgetReportOutput,
+];
+var BatchUpdateExclusionWindows = [
+    9,
+    n0,
+    _BUEW,
+    {
+        [_h]: ["PATCH", "/exclusion-windows", 200],
+    },
+    () => BatchUpdateExclusionWindowsInput,
+    () => BatchUpdateExclusionWindowsOutput,
+];
+var CreateServiceLevelObjective = [
+    9,
+    n0,
+    _CSLO,
+    {
+        [_h]: ["POST", "/slo", 200],
+    },
+    () => CreateServiceLevelObjectiveInput,
+    () => CreateServiceLevelObjectiveOutput,
+];
+var DeleteGroupingConfiguration = [
+    9,
+    n0,
+    _DGC,
+    {
+        [_h]: ["DELETE", "/grouping-configuration", 200],
+    },
+    () => __Unit,
+    () => DeleteGroupingConfigurationOutput,
+];
+var DeleteServiceLevelObjective = [
+    9,
+    n0,
+    _DSLO,
+    {
+        [_h]: ["DELETE", "/slo/{Id}", 200],
+    },
+    () => DeleteServiceLevelObjectiveInput,
+    () => DeleteServiceLevelObjectiveOutput,
+];
+var GetService = [
+    9,
+    n0,
+    _GSe,
+    {
+        [_h]: ["POST", "/service", 200],
+    },
+    () => GetServiceInput,
+    () => GetServiceOutput,
+];
+var GetServiceLevelObjective = [
+    9,
+    n0,
+    _GSLO,
+    {
+        [_h]: ["GET", "/slo/{Id}", 200],
+    },
+    () => GetServiceLevelObjectiveInput,
+    () => GetServiceLevelObjectiveOutput,
+];
+var ListAuditFindings = [
+    9,
+    n0,
+    _LAF,
+    {
+        [_h]: ["POST", "/auditFindings", 200],
+    },
+    () => ListAuditFindingsInput,
+    () => ListAuditFindingsOutput,
+];
+var ListGroupingAttributeDefinitions = [
+    9,
+    n0,
+    _LGAD,
+    {
+        [_h]: ["POST", "/grouping-attribute-definitions", 200],
+    },
+    () => ListGroupingAttributeDefinitionsInput,
+    () => ListGroupingAttributeDefinitionsOutput,
+];
+var ListServiceDependencies = [
+    9,
+    n0,
+    _LSD,
+    {
+        [_h]: ["POST", "/service-dependencies", 200],
+    },
+    () => ListServiceDependenciesInput,
+    () => ListServiceDependenciesOutput,
+];
+var ListServiceDependents = [
+    9,
+    n0,
+    _LSDi,
+    {
+        [_h]: ["POST", "/service-dependents", 200],
+    },
+    () => ListServiceDependentsInput,
+    () => ListServiceDependentsOutput,
+];
+var ListServiceLevelObjectiveExclusionWindows = [
+    9,
+    n0,
+    _LSLOEW,
+    {
+        [_h]: ["GET", "/slo/{Id}/exclusion-windows", 200],
+    },
+    () => ListServiceLevelObjectiveExclusionWindowsInput,
+    () => ListServiceLevelObjectiveExclusionWindowsOutput,
+];
+var ListServiceLevelObjectives = [
+    9,
+    n0,
+    _LSLO,
+    {
+        [_h]: ["POST", "/slos", 200],
+    },
+    () => ListServiceLevelObjectivesInput,
+    () => ListServiceLevelObjectivesOutput,
+];
+var ListServiceOperations = [
+    9,
+    n0,
+    _LSOi,
+    {
+        [_h]: ["POST", "/service-operations", 200],
+    },
+    () => ListServiceOperationsInput,
+    () => ListServiceOperationsOutput,
+];
+var ListServices = [
+    9,
+    n0,
+    _LS,
+    {
+        [_h]: ["GET", "/services", 200],
+    },
+    () => ListServicesInput,
+    () => ListServicesOutput,
+];
+var ListServiceStates = [
+    9,
+    n0,
+    _LSS,
+    {
+        [_h]: ["POST", "/service/states", 200],
+    },
+    () => ListServiceStatesInput,
+    () => ListServiceStatesOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PutGroupingConfiguration = [
+    9,
+    n0,
+    _PGC,
+    {
+        [_h]: ["PUT", "/grouping-configuration", 200],
+    },
+    () => PutGroupingConfigurationInput,
+    () => PutGroupingConfigurationOutput,
+];
+var StartDiscovery = [
+    9,
+    n0,
+    _SDt,
+    {
+        [_h]: ["POST", "/start-discovery", 200],
+    },
+    () => StartDiscoveryInput,
+    () => StartDiscoveryOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tag-resource", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/untag-resource", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateServiceLevelObjective = [
+    9,
+    n0,
+    _USLO,
+    {
+        [_h]: ["PATCH", "/slo/{Id}", 200],
+    },
+    () => UpdateServiceLevelObjectiveInput,
+    () => UpdateServiceLevelObjectiveOutput,
+];
 
 class BatchGetServiceLevelObjectiveBudgetReportCommand 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("ApplicationSignals", "BatchGetServiceLevelObjectiveBudgetReport", {})
     .n("ApplicationSignalsClient", "BatchGetServiceLevelObjectiveBudgetReportCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchGetServiceLevelObjectiveBudgetReportCommand)
-    .de(de_BatchGetServiceLevelObjectiveBudgetReportCommand)
+    .sc(BatchGetServiceLevelObjectiveBudgetReport)
     .build() {
 }
 
@@ -1376,16 +1685,11 @@ class BatchUpdateExclusionWindowsCommand 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("ApplicationSignals", "BatchUpdateExclusionWindows", {})
     .n("ApplicationSignalsClient", "BatchUpdateExclusionWindowsCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchUpdateExclusionWindowsCommand)
-    .de(de_BatchUpdateExclusionWindowsCommand)
+    .sc(BatchUpdateExclusionWindows)
     .build() {
 }
 
@@ -1393,16 +1697,11 @@ class CreateServiceLevelObjectiveCommand 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("ApplicationSignals", "CreateServiceLevelObjective", {})
     .n("ApplicationSignalsClient", "CreateServiceLevelObjectiveCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateServiceLevelObjectiveCommand)
-    .de(de_CreateServiceLevelObjectiveCommand)
+    .sc(CreateServiceLevelObjective)
     .build() {
 }
 
@@ -1410,16 +1709,11 @@ class DeleteGroupingConfigurationCommand 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("ApplicationSignals", "DeleteGroupingConfiguration", {})
     .n("ApplicationSignalsClient", "DeleteGroupingConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteGroupingConfigurationCommand)
-    .de(de_DeleteGroupingConfigurationCommand)
+    .sc(DeleteGroupingConfiguration)
     .build() {
 }
 
@@ -1427,16 +1721,11 @@ class DeleteServiceLevelObjectiveCommand 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("ApplicationSignals", "DeleteServiceLevelObjective", {})
     .n("ApplicationSignalsClient", "DeleteServiceLevelObjectiveCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteServiceLevelObjectiveCommand)
-    .de(de_DeleteServiceLevelObjectiveCommand)
+    .sc(DeleteServiceLevelObjective)
     .build() {
 }
 
@@ -1444,16 +1733,11 @@ class GetServiceCommand 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("ApplicationSignals", "GetService", {})
     .n("ApplicationSignalsClient", "GetServiceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetServiceCommand)
-    .de(de_GetServiceCommand)
+    .sc(GetService)
     .build() {
 }
 
@@ -1461,16 +1745,11 @@ class GetServiceLevelObjectiveCommand 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("ApplicationSignals", "GetServiceLevelObjective", {})
     .n("ApplicationSignalsClient", "GetServiceLevelObjectiveCommand")
-    .f(void 0, void 0)
-    .ser(se_GetServiceLevelObjectiveCommand)
-    .de(de_GetServiceLevelObjectiveCommand)
+    .sc(GetServiceLevelObjective)
     .build() {
 }
 
@@ -1478,16 +1757,11 @@ class ListAuditFindingsCommand 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("ApplicationSignals", "ListAuditFindings", {})
     .n("ApplicationSignalsClient", "ListAuditFindingsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListAuditFindingsCommand)
-    .de(de_ListAuditFindingsCommand)
+    .sc(ListAuditFindings)
     .build() {
 }
 
@@ -1495,16 +1769,11 @@ class ListGroupingAttributeDefinitionsCommand 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("ApplicationSignals", "ListGroupingAttributeDefinitions", {})
     .n("ApplicationSignalsClient", "ListGroupingAttributeDefinitionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListGroupingAttributeDefinitionsCommand)
-    .de(de_ListGroupingAttributeDefinitionsCommand)
+    .sc(ListGroupingAttributeDefinitions)
     .build() {
 }
 
@@ -1512,16 +1781,11 @@ class ListServiceDependenciesCommand 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("ApplicationSignals", "ListServiceDependencies", {})
     .n("ApplicationSignalsClient", "ListServiceDependenciesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceDependenciesCommand)
-    .de(de_ListServiceDependenciesCommand)
+    .sc(ListServiceDependencies)
     .build() {
 }
 
@@ -1529,16 +1793,11 @@ class ListServiceDependentsCommand 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("ApplicationSignals", "ListServiceDependents", {})
     .n("ApplicationSignalsClient", "ListServiceDependentsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceDependentsCommand)
-    .de(de_ListServiceDependentsCommand)
+    .sc(ListServiceDependents)
     .build() {
 }
 
@@ -1546,16 +1805,11 @@ class ListServiceLevelObjectiveExclusionWindowsCommand extends smithyClient.Comm
     .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("ApplicationSignals", "ListServiceLevelObjectiveExclusionWindows", {})
     .n("ApplicationSignalsClient", "ListServiceLevelObjectiveExclusionWindowsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceLevelObjectiveExclusionWindowsCommand)
-    .de(de_ListServiceLevelObjectiveExclusionWindowsCommand)
+    .sc(ListServiceLevelObjectiveExclusionWindows)
     .build() {
 }
 
@@ -1563,16 +1817,11 @@ class ListServiceLevelObjectivesCommand 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("ApplicationSignals", "ListServiceLevelObjectives", {})
     .n("ApplicationSignalsClient", "ListServiceLevelObjectivesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceLevelObjectivesCommand)
-    .de(de_ListServiceLevelObjectivesCommand)
+    .sc(ListServiceLevelObjectives)
     .build() {
 }
 
@@ -1580,16 +1829,11 @@ class ListServiceOperationsCommand 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("ApplicationSignals", "ListServiceOperations", {})
     .n("ApplicationSignalsClient", "ListServiceOperationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceOperationsCommand)
-    .de(de_ListServiceOperationsCommand)
+    .sc(ListServiceOperations)
     .build() {
 }
 
@@ -1597,16 +1841,11 @@ class ListServicesCommand 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("ApplicationSignals", "ListServices", {})
     .n("ApplicationSignalsClient", "ListServicesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServicesCommand)
-    .de(de_ListServicesCommand)
+    .sc(ListServices)
     .build() {
 }
 
@@ -1614,16 +1853,11 @@ class ListServiceStatesCommand 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("ApplicationSignals", "ListServiceStates", {})
     .n("ApplicationSignalsClient", "ListServiceStatesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListServiceStatesCommand)
-    .de(de_ListServiceStatesCommand)
+    .sc(ListServiceStates)
     .build() {
 }
 
@@ -1631,16 +1865,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("ApplicationSignals", "ListTagsForResource", {})
     .n("ApplicationSignalsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1648,16 +1877,11 @@ class PutGroupingConfigurationCommand 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("ApplicationSignals", "PutGroupingConfiguration", {})
     .n("ApplicationSignalsClient", "PutGroupingConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_PutGroupingConfigurationCommand)
-    .de(de_PutGroupingConfigurationCommand)
+    .sc(PutGroupingConfiguration)
     .build() {
 }
 
@@ -1665,16 +1889,11 @@ class StartDiscoveryCommand 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("ApplicationSignals", "StartDiscovery", {})
     .n("ApplicationSignalsClient", "StartDiscoveryCommand")
-    .f(void 0, void 0)
-    .ser(se_StartDiscoveryCommand)
-    .de(de_StartDiscoveryCommand)
+    .sc(StartDiscovery)
     .build() {
 }
 
@@ -1682,16 +1901,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("ApplicationSignals", "TagResource", {})
     .n("ApplicationSignalsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1699,16 +1913,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("ApplicationSignals", "UntagResource", {})
     .n("ApplicationSignalsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1716,16 +1925,11 @@ class UpdateServiceLevelObjectiveCommand 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("ApplicationSignals", "UpdateServiceLevelObjective", {})
     .n("ApplicationSignalsClient", "UpdateServiceLevelObjectiveCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateServiceLevelObjectiveCommand)
-    .de(de_UpdateServiceLevelObjectiveCommand)
+    .sc(UpdateServiceLevelObjective)
     .build() {
 }
 
@@ -1779,14 +1983,14 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.ApplicationSignals = ApplicationSignals;
 exports.ApplicationSignalsClient = ApplicationSignalsClient;
-exports.ApplicationSignalsServiceException = ApplicationSignalsServiceException;
+exports.ApplicationSignalsServiceException = ApplicationSignalsServiceException$1;
 exports.BatchGetServiceLevelObjectiveBudgetReportCommand = BatchGetServiceLevelObjectiveBudgetReportCommand;
 exports.BatchUpdateExclusionWindowsCommand = BatchUpdateExclusionWindowsCommand;
 exports.ChangeEventType = ChangeEventType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ConnectionType = ConnectionType;
 exports.CreateServiceLevelObjectiveCommand = CreateServiceLevelObjectiveCommand;
 exports.DeleteGroupingConfigurationCommand = DeleteGroupingConfigurationCommand;
@@ -1807,19 +2011,19 @@ exports.ListServicesCommand = ListServicesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.MetricSourceType = MetricSourceType;
 exports.PutGroupingConfigurationCommand = PutGroupingConfigurationCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ServiceLevelIndicatorComparisonOperator = ServiceLevelIndicatorComparisonOperator;
 exports.ServiceLevelIndicatorMetricType = ServiceLevelIndicatorMetricType;
 exports.ServiceLevelObjectiveBudgetStatus = ServiceLevelObjectiveBudgetStatus;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.Severity = Severity;
 exports.StandardUnit = StandardUnit;
 exports.StartDiscoveryCommand = StartDiscoveryCommand;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateServiceLevelObjectiveCommand = UpdateServiceLevelObjectiveCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListServiceDependencies = paginateListServiceDependencies;
 exports.paginateListServiceDependents = paginateListServiceDependents;
 exports.paginateListServiceLevelObjectiveExclusionWindows = paginateListServiceLevelObjectiveExclusionWindows;