@aws-sdk/client-codeguru-security 3.928.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,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class CodeGuruSecurityClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class CodeGuruSecurityClient extends smithyClient.Client {
     }
 }
 
-class CodeGuruSecurityServiceException extends smithyClient.ServiceException {
+let CodeGuruSecurityServiceException$1 = class CodeGuruSecurityServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, CodeGuruSecurityServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends CodeGuruSecurityServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends CodeGuruSecurityServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     errorCode;
@@ -135,7 +134,7 @@ class AccessDeniedException extends CodeGuruSecurityServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
+};
 const AnalysisType = {
     ALL: "All",
     SECURITY: "Security",
@@ -159,7 +158,7 @@ const Status = {
     CLOSED: "Closed",
     OPEN: "Open",
 };
-class InternalServerException extends CodeGuruSecurityServiceException {
+let InternalServerException$1 = class InternalServerException extends CodeGuruSecurityServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -173,8 +172,8 @@ class InternalServerException extends CodeGuruSecurityServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.error = opts.error;
     }
-}
-class ThrottlingException extends CodeGuruSecurityServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends CodeGuruSecurityServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -194,7 +193,7 @@ class ThrottlingException extends CodeGuruSecurityServiceException {
         this.serviceCode = opts.serviceCode;
         this.quotaCode = opts.quotaCode;
     }
-}
+};
 const ValidationExceptionReason = {
     CANNOT_PARSE: "cannotParse",
     FIELD_VALIDATION_FAILED: "fieldValidationFailed",
@@ -202,7 +201,7 @@ const ValidationExceptionReason = {
     OTHER: "other",
     UNKNOWN_OPERATION: "unknownOperation",
 };
-class ValidationException extends CodeGuruSecurityServiceException {
+let ValidationException$1 = class ValidationException extends CodeGuruSecurityServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     errorCode;
@@ -219,8 +218,8 @@ class ValidationException extends CodeGuruSecurityServiceException {
         this.reason = opts.reason;
         this.fieldList = opts.fieldList;
     }
-}
-class ConflictException extends CodeGuruSecurityServiceException {
+};
+let ConflictException$1 = class ConflictException extends CodeGuruSecurityServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     errorCode;
@@ -237,7 +236,7 @@ class ConflictException extends CodeGuruSecurityServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
+};
 exports.ResourceId = void 0;
 (function (ResourceId) {
     ResourceId.visit = (value, visitor) => {
@@ -255,7 +254,7 @@ const ScanState = {
     IN_PROGRESS: "InProgress",
     SUCCESSFUL: "Successful",
 };
-class ResourceNotFoundException extends CodeGuruSecurityServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends CodeGuruSecurityServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     errorCode;
@@ -272,607 +271,696 @@ class ResourceNotFoundException extends CodeGuruSecurityServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
-const CreateUploadUrlResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.s3Url && { s3Url: smithyClient.SENSITIVE_STRING }),
-    ...(obj.requestHeaders && { requestHeaders: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_BatchGetFindingsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/batchGetFindings");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        findingIdentifiers: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateScanCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/scans");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        analysisType: [],
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        resourceId: (_) => smithyClient._json(_),
-        scanName: [],
-        scanType: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateUploadUrlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/uploadUrl");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        scanName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetAccountConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/accountConfiguration/get");
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetFindingsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/findings/{scanName}");
-    b.p("scanName", () => input.scanName, "{scanName}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_s]: [, input[_s]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetMetricsSummaryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/metrics/summary");
-    const query = smithyClient.map({
-        [_d]: [smithyClient.expectNonNull(input.date, `date`) != null, () => smithyClient.serializeDateTime(input[_d]).toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetScanCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/scans/{scanName}");
-    b.p("scanName", () => input.scanName, "{scanName}", false);
-    const query = smithyClient.map({
-        [_rI]: [, input[_rI]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListFindingsMetricsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/metrics/findings");
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_sD]: [smithyClient.expectNonNull(input.startDate, `startDate`) != null, () => smithyClient.serializeDateTime(input[_sD]).toString()],
-        [_eD]: [smithyClient.expectNonNull(input.endDate, `endDate`) != null, () => smithyClient.serializeDateTime(input[_eD]).toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListScansCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/scans");
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateAccountConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/updateAccountConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        encryptionConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const de_BatchGetFindingsCommand = 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, {
-        failedFindings: smithyClient._json,
-        findings: (_) => de_Findings(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateScanCommand = 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, {
-        resourceId: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        runId: smithyClient.expectString,
-        scanName: smithyClient.expectString,
-        scanNameArn: smithyClient.expectString,
-        scanState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateUploadUrlCommand = 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, {
-        codeArtifactId: smithyClient.expectString,
-        requestHeaders: smithyClient._json,
-        s3Url: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetAccountConfigurationCommand = 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, {
-        encryptionConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetFindingsCommand = 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, {
-        findings: (_) => de_Findings(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetMetricsSummaryCommand = 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, {
-        metricsSummary: (_) => de_MetricsSummary(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
 };
-const de_GetScanCommand = 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, {
-        analysisType: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        errorMessage: smithyClient.expectString,
-        numberOfRevisions: smithyClient.expectLong,
-        runId: smithyClient.expectString,
-        scanName: smithyClient.expectString,
-        scanNameArn: smithyClient.expectString,
-        scanState: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListFindingsMetricsCommand = 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, {
-        findingsMetrics: (_) => de_FindingsMetricList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListScansCommand = 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,
-        summaries: (_) => de_ScanSummaries(_),
-    });
-    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_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && 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 !== 204 && 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_UpdateAccountConfigurationCommand = 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, {
-        encryptionConfig: smithyClient._json,
-    });
-    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 "AccessDeniedException":
-        case "com.amazonaws.codegurusecurity#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.codegurusecurity#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.codegurusecurity#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.codegurusecurity#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.codegurusecurity#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.codegurusecurity#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(CodeGuruSecurityServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        errorCode: smithyClient.expectString,
-        message: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: 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, {
-        errorCode: smithyClient.expectString,
-        message: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $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, {
-        errorCode: smithyClient.expectString,
-        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_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        errorCode: smithyClient.expectString,
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        errorCode: smithyClient.expectString,
-        fieldList: smithyClient._json,
-        message: smithyClient.expectString,
-        reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_AccountFindingsMetric = (output, context) => {
-    return smithyClient.take(output, {
-        closedFindings: (_) => de_FindingMetricsValuePerSeverity(_),
-        date: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        meanTimeToClose: (_) => de_FindingMetricsValuePerSeverity(_),
-        newFindings: (_) => de_FindingMetricsValuePerSeverity(_),
-        openFindings: (_) => de_FindingMetricsValuePerSeverity(_),
-    });
-};
-const de_Finding = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        detectorId: smithyClient.expectString,
-        detectorName: smithyClient.expectString,
-        detectorTags: smithyClient._json,
-        generatorId: smithyClient.expectString,
-        id: smithyClient.expectString,
-        remediation: smithyClient._json,
-        resource: smithyClient._json,
-        ruleId: smithyClient.expectString,
-        severity: smithyClient.expectString,
-        status: smithyClient.expectString,
-        title: smithyClient.expectString,
-        type: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        vulnerability: smithyClient._json,
-    });
-};
-const de_FindingMetricsValuePerSeverity = (output, context) => {
-    return smithyClient.take(output, {
-        critical: smithyClient.limitedParseDouble,
-        high: smithyClient.limitedParseDouble,
-        info: smithyClient.limitedParseDouble,
-        low: smithyClient.limitedParseDouble,
-        medium: smithyClient.limitedParseDouble,
-    });
-};
-const de_Findings = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Finding(entry);
-    });
-    return retVal;
-};
-const de_FindingsMetricList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AccountFindingsMetric(entry);
-    });
-    return retVal;
-};
-const de_MetricsSummary = (output, context) => {
-    return smithyClient.take(output, {
-        categoriesWithMostFindings: smithyClient._json,
-        date: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        openFindings: (_) => de_FindingMetricsValuePerSeverity(_),
-        scansWithMostOpenCriticalFindings: smithyClient._json,
-        scansWithMostOpenFindings: smithyClient._json,
-    });
-};
-const de_ScanSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScanSummary(entry);
-    });
-    return retVal;
-};
-const de_ScanSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        runId: smithyClient.expectString,
-        scanName: smithyClient.expectString,
-        scanNameArn: smithyClient.expectString,
-        scanState: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-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 _ADE = "AccessDeniedException";
+const _AFM = "AccountFindingsMetric";
+const _BGF = "BatchGetFindings";
+const _BGFE = "BatchGetFindingsError";
+const _BGFEa = "BatchGetFindingsErrors";
+const _BGFR = "BatchGetFindingsRequest";
+const _BGFRa = "BatchGetFindingsResponse";
+const _CE = "ConflictException";
+const _CL = "CodeLine";
+const _CS = "CodeSnippet";
+const _CSR = "CreateScanRequest";
+const _CSRr = "CreateScanResponse";
+const _CSr = "CreateScan";
+const _CUU = "CreateUploadUrl";
+const _CUUR = "CreateUploadUrlRequest";
+const _CUURr = "CreateUploadUrlResponse";
+const _CWFN = "CategoryWithFindingNum";
+const _CWMF = "CategoriesWithMostFindings";
+const _EC = "EncryptionConfig";
+const _F = "Finding";
+const _FI = "FindingIdentifier";
+const _FIi = "FindingIdentifiers";
+const _FML = "FindingsMetricList";
+const _FMVPS = "FindingMetricsValuePerSeverity";
+const _FP = "FilePath";
+const _Fi = "Findings";
+const _GAC = "GetAccountConfiguration";
+const _GACR = "GetAccountConfigurationRequest";
+const _GACRe = "GetAccountConfigurationResponse";
+const _GF = "GetFindings";
+const _GFR = "GetFindingsRequest";
+const _GFRe = "GetFindingsResponse";
+const _GMS = "GetMetricsSummary";
+const _GMSR = "GetMetricsSummaryRequest";
+const _GMSRe = "GetMetricsSummaryResponse";
+const _GS = "GetScan";
+const _GSR = "GetScanRequest";
+const _GSRe = "GetScanResponse";
+const _ISE = "InternalServerException";
+const _LFM = "ListFindingsMetrics";
+const _LFMR = "ListFindingsMetricsRequest";
+const _LFMRi = "ListFindingsMetricsResponse";
+const _LS = "ListScans";
+const _LSR = "ListScansRequest";
+const _LSRi = "ListScansResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _MS = "MetricsSummary";
+const _R = "Recommendation";
+const _RHM = "RequestHeaderMap";
+const _RI = "ResourceId";
+const _RNFE = "ResourceNotFoundException";
+const _Re = "Remediation";
+const _Res = "Resource";
+const _SF = "SuggestedFix";
+const _SFu = "SuggestedFixes";
+const _SNWFN = "ScanNameWithFindingNum";
+const _SS = "ScanSummary";
+const _SSc = "ScanSummaries";
+const _SU = "S3Url";
+const _SWMOCF = "ScansWithMostOpenCriticalFindings";
+const _SWMOF = "ScansWithMostOpenFindings";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UAC = "UpdateAccountConfiguration";
+const _UACR = "UpdateAccountConfigurationRequest";
+const _UACRp = "UpdateAccountConfigurationResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Vulnerability";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _aT = "analysisType";
+const _c = "client";
+const _cA = "createdAt";
+const _cAI = "codeArtifactId";
+const _cF = "closedFindings";
+const _cN = "categoryName";
+const _cS = "codeSnippet";
+const _cT = "clientToken";
+const _cWMF = "categoriesWithMostFindings";
+const _co = "content";
+const _cod = "code";
+const _cr = "critical";
 const _d = "date";
+const _dI = "detectorId";
+const _dN = "detectorName";
+const _dT = "detectorTags";
+const _de = "description";
+const _e = "error";
+const _eC = "errorCode";
+const _eCn = "encryptionConfig";
 const _eD = "endDate";
+const _eL = "endLine";
+const _eM = "errorMessage";
+const _f = "findings";
+const _fF = "failedFindings";
+const _fI = "findingId";
+const _fIi = "findingIdentifiers";
+const _fL = "fieldList";
+const _fM = "findingsMetrics";
+const _fN = "findingNumber";
+const _fP = "filePath";
+const _gI = "generatorId";
+const _h = "high";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _ht = "http";
+const _i = "id";
+const _iC = "itemCount";
+const _in = "info";
+const _kKA = "kmsKeyArn";
+const _l = "low";
+const _m = "message";
 const _mR = "maxResults";
+const _mS = "metricsSummary";
+const _mTTC = "meanTimeToClose";
+const _me = "medium";
+const _n = "number";
+const _nF = "newFindings";
+const _nOR = "numberOfRevisions";
 const _nT = "nextToken";
-const _rI = "runId";
+const _na = "name";
+const _oF = "openFindings";
+const _p = "path";
+const _qC = "quotaCode";
+const _r = "resource";
+const _rA = "resourceArn";
+const _rH = "requestHeaders";
+const _rI = "resourceId";
+const _rIu = "runId";
+const _rIul = "ruleId";
+const _rT = "resourceType";
+const _rU = "referenceUrls";
+const _rV = "relatedVulnerabilities";
+const _re = "remediation";
+const _rea = "reason";
+const _rec = "recommendation";
 const _s = "status";
+const _sC = "serviceCode";
 const _sD = "startDate";
+const _sF = "suggestedFixes";
+const _sL = "startLine";
+const _sN = "scanName";
+const _sNA = "scanNameArn";
+const _sRI = "subResourceId";
+const _sS = "scanState";
+const _sT = "scanType";
+const _sU = "s3Url";
+const _sWMOCF = "scansWithMostOpenCriticalFindings";
+const _sWMOF = "scansWithMostOpenFindings";
+const _se = "severity";
+const _ser = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.codegurusecurity";
+const _su = "summaries";
+const _t = "tags";
 const _tK = "tagKeys";
+const _te = "text";
+const _ti = "title";
+const _ty = "type";
+const _u = "url";
+const _uA = "updatedAt";
+const _v = "vulnerability";
+const n0 = "com.amazonaws.codegurusecurity";
+var S3Url = [0, n0, _SU, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_eC, _m, _rI, _rT],
+    [0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AccountFindingsMetric = [
+    3,
+    n0,
+    _AFM,
+    0,
+    [_d, _nF, _cF, _oF, _mTTC],
+    [
+        4,
+        () => FindingMetricsValuePerSeverity,
+        () => FindingMetricsValuePerSeverity,
+        () => FindingMetricsValuePerSeverity,
+        () => FindingMetricsValuePerSeverity,
+    ],
+];
+var BatchGetFindingsError = [3, n0, _BGFE, 0, [_sN, _fI, _eC, _m], [0, 0, 0, 0]];
+var BatchGetFindingsRequest = [3, n0, _BGFR, 0, [_fIi], [() => FindingIdentifiers]];
+var BatchGetFindingsResponse = [
+    3,
+    n0,
+    _BGFRa,
+    0,
+    [_f, _fF],
+    [() => Findings, () => BatchGetFindingsErrors],
+];
+var CategoryWithFindingNum = [3, n0, _CWFN, 0, [_cN, _fN], [0, 1]];
+var CodeLine = [3, n0, _CL, 0, [_n, _co], [1, 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_eC, _m, _rI, _rT],
+    [0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateScanRequest = [
+    3,
+    n0,
+    _CSR,
+    0,
+    [_cT, _rI, _sN, _sT, _aT, _t],
+    [[0, 4], () => ResourceId, 0, 0, 0, 128 | 0],
+];
+var CreateScanResponse = [
+    3,
+    n0,
+    _CSRr,
+    0,
+    [_sN, _rIu, _rI, _sS, _sNA],
+    [0, 0, () => ResourceId, 0, 0],
+];
+var CreateUploadUrlRequest = [3, n0, _CUUR, 0, [_sN], [0]];
+var CreateUploadUrlResponse = [
+    3,
+    n0,
+    _CUURr,
+    0,
+    [_sU, _rH, _cAI],
+    [[() => S3Url, 0], [() => RequestHeaderMap, 0], 0],
+];
+var EncryptionConfig = [3, n0, _EC, 0, [_kKA], [0]];
+var FilePath = [3, n0, _FP, 0, [_na, _p, _sL, _eL, _cS], [0, 0, 1, 1, () => CodeSnippet]];
+var Finding = [
+    3,
+    n0,
+    _F,
+    0,
+    [_cA, _de, _gI, _i, _uA, _ty, _s, _r, _v, _se, _re, _ti, _dT, _dI, _dN, _rIul],
+    [4, 0, 0, 0, 4, 0, 0, () => Resource, () => Vulnerability, 0, () => Remediation, 0, 64 | 0, 0, 0, 0],
+];
+var FindingIdentifier = [3, n0, _FI, 0, [_sN, _fI], [0, 0]];
+var FindingMetricsValuePerSeverity = [
+    3,
+    n0,
+    _FMVPS,
+    0,
+    [_in, _l, _me, _h, _cr],
+    [1, 1, 1, 1, 1],
+];
+var GetAccountConfigurationRequest = [3, n0, _GACR, 0, [], []];
+var GetAccountConfigurationResponse = [
+    3,
+    n0,
+    _GACRe,
+    0,
+    [_eCn],
+    [() => EncryptionConfig],
+];
+var GetFindingsRequest = [
+    3,
+    n0,
+    _GFR,
+    0,
+    [_sN, _nT, _mR, _s],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _s,
+            },
+        ],
+    ],
+];
+var GetFindingsResponse = [3, n0, _GFRe, 0, [_f, _nT], [() => Findings, 0]];
+var GetMetricsSummaryRequest = [
+    3,
+    n0,
+    _GMSR,
+    0,
+    [_d],
+    [
+        [
+            4,
+            {
+                [_hQ]: _d,
+            },
+        ],
+    ],
+];
+var GetMetricsSummaryResponse = [3, n0, _GMSRe, 0, [_mS], [() => MetricsSummary]];
+var GetScanRequest = [
+    3,
+    n0,
+    _GSR,
+    0,
+    [_sN, _rIu],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _rIu,
+            },
+        ],
+    ],
+];
+var GetScanResponse = [
+    3,
+    n0,
+    _GSRe,
+    0,
+    [_sN, _rIu, _sS, _cA, _aT, _uA, _nOR, _sNA, _eM],
+    [0, 0, 0, 4, 0, 4, 1, 0, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _ser,
+        [_hE]: 500,
+    },
+    [_e, _m],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListFindingsMetricsRequest = [
+    3,
+    n0,
+    _LFMR,
+    0,
+    [_nT, _mR, _sD, _eD],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _sD,
+            },
+        ],
+        [
+            4,
+            {
+                [_hQ]: _eD,
+            },
+        ],
+    ],
+];
+var ListFindingsMetricsResponse = [
+    3,
+    n0,
+    _LFMRi,
+    0,
+    [_fM, _nT],
+    [() => FindingsMetricList, 0],
+];
+var ListScansRequest = [
+    3,
+    n0,
+    _LSR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListScansResponse = [3, n0, _LSRi, 0, [_su, _nT], [() => ScanSummaries, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
+var MetricsSummary = [
+    3,
+    n0,
+    _MS,
+    0,
+    [_d, _oF, _cWMF, _sWMOF, _sWMOCF],
+    [
+        4,
+        () => FindingMetricsValuePerSeverity,
+        () => CategoriesWithMostFindings,
+        () => ScansWithMostOpenFindings,
+        () => ScansWithMostOpenCriticalFindings,
+    ],
+];
+var Recommendation = [3, n0, _R, 0, [_te, _u], [0, 0]];
+var Remediation = [
+    3,
+    n0,
+    _Re,
+    0,
+    [_rec, _sF],
+    [() => Recommendation, () => SuggestedFixes],
+];
+var Resource = [3, n0, _Res, 0, [_i, _sRI], [0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_eC, _m, _rI, _rT],
+    [0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ScanNameWithFindingNum = [3, n0, _SNWFN, 0, [_sN, _fN], [0, 1]];
+var ScanSummary = [3, n0, _SS, 0, [_sS, _cA, _uA, _sN, _rIu, _sNA], [0, 4, 4, 0, 0, 0]];
+var SuggestedFix = [3, n0, _SF, 0, [_de, _cod], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_eC, _m, _sC, _qC],
+    [0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateAccountConfigurationRequest = [
+    3,
+    n0,
+    _UACR,
+    0,
+    [_eCn],
+    [() => EncryptionConfig],
+];
+var UpdateAccountConfigurationResponse = [
+    3,
+    n0,
+    _UACRp,
+    0,
+    [_eCn],
+    [() => EncryptionConfig],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_eC, _m, _rea, _fL],
+    [0, 0, 0, () => ValidationExceptionFieldList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_na, _m], [0, 0]];
+var Vulnerability = [
+    3,
+    n0,
+    _V,
+    0,
+    [_rU, _rV, _i, _fP, _iC],
+    [64 | 0, 64 | 0, 0, () => FilePath, 1],
+];
+var CodeGuruSecurityServiceException = [
+    -3,
+    _sm,
+    "CodeGuruSecurityServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(CodeGuruSecurityServiceException, CodeGuruSecurityServiceException$1);
+var BatchGetFindingsErrors = [1, n0, _BGFEa, 0, () => BatchGetFindingsError];
+var CategoriesWithMostFindings = [1, n0, _CWMF, 0, () => CategoryWithFindingNum];
+var CodeSnippet = [1, n0, _CS, 0, () => CodeLine];
+var FindingIdentifiers = [1, n0, _FIi, 0, () => FindingIdentifier];
+var Findings = [1, n0, _Fi, 0, () => Finding];
+var FindingsMetricList = [1, n0, _FML, 0, () => AccountFindingsMetric];
+var ScanSummaries = [1, n0, _SSc, 0, () => ScanSummary];
+var ScansWithMostOpenCriticalFindings = [1, n0, _SWMOCF, 0, () => ScanNameWithFindingNum];
+var ScansWithMostOpenFindings = [1, n0, _SWMOF, 0, () => ScanNameWithFindingNum];
+var SuggestedFixes = [1, n0, _SFu, 0, () => SuggestedFix];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
+var RequestHeaderMap = [2, n0, _RHM, 8, 0, 0];
+var ResourceId = [3, n0, _RI, 0, [_cAI], [0]];
+var BatchGetFindings = [
+    9,
+    n0,
+    _BGF,
+    {
+        [_ht]: ["POST", "/batchGetFindings", 200],
+    },
+    () => BatchGetFindingsRequest,
+    () => BatchGetFindingsResponse,
+];
+var CreateScan = [
+    9,
+    n0,
+    _CSr,
+    {
+        [_ht]: ["POST", "/scans", 200],
+    },
+    () => CreateScanRequest,
+    () => CreateScanResponse,
+];
+var CreateUploadUrl = [
+    9,
+    n0,
+    _CUU,
+    {
+        [_ht]: ["POST", "/uploadUrl", 200],
+    },
+    () => CreateUploadUrlRequest,
+    () => CreateUploadUrlResponse,
+];
+var GetAccountConfiguration = [
+    9,
+    n0,
+    _GAC,
+    {
+        [_ht]: ["GET", "/accountConfiguration/get", 200],
+    },
+    () => GetAccountConfigurationRequest,
+    () => GetAccountConfigurationResponse,
+];
+var GetFindings = [
+    9,
+    n0,
+    _GF,
+    {
+        [_ht]: ["GET", "/findings/{scanName}", 200],
+    },
+    () => GetFindingsRequest,
+    () => GetFindingsResponse,
+];
+var GetMetricsSummary = [
+    9,
+    n0,
+    _GMS,
+    {
+        [_ht]: ["GET", "/metrics/summary", 200],
+    },
+    () => GetMetricsSummaryRequest,
+    () => GetMetricsSummaryResponse,
+];
+var GetScan = [
+    9,
+    n0,
+    _GS,
+    {
+        [_ht]: ["GET", "/scans/{scanName}", 200],
+    },
+    () => GetScanRequest,
+    () => GetScanResponse,
+];
+var ListFindingsMetrics = [
+    9,
+    n0,
+    _LFM,
+    {
+        [_ht]: ["GET", "/metrics/findings", 200],
+    },
+    () => ListFindingsMetricsRequest,
+    () => ListFindingsMetricsResponse,
+];
+var ListScans = [
+    9,
+    n0,
+    _LS,
+    {
+        [_ht]: ["GET", "/scans", 200],
+    },
+    () => ListScansRequest,
+    () => ListScansResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_ht]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_ht]: ["POST", "/tags/{resourceArn}", 204],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_ht]: ["DELETE", "/tags/{resourceArn}", 204],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateAccountConfiguration = [
+    9,
+    n0,
+    _UAC,
+    {
+        [_ht]: ["PUT", "/updateAccountConfiguration", 200],
+    },
+    () => UpdateAccountConfigurationRequest,
+    () => UpdateAccountConfigurationResponse,
+];
 
 class BatchGetFindingsCommand 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("AwsCodeGuruSecurity", "BatchGetFindings", {})
     .n("CodeGuruSecurityClient", "BatchGetFindingsCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchGetFindingsCommand)
-    .de(de_BatchGetFindingsCommand)
+    .sc(BatchGetFindings)
     .build() {
 }
 
@@ -880,16 +968,11 @@ class CreateScanCommand 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("AwsCodeGuruSecurity", "CreateScan", {})
     .n("CodeGuruSecurityClient", "CreateScanCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateScanCommand)
-    .de(de_CreateScanCommand)
+    .sc(CreateScan)
     .build() {
 }
 
@@ -897,16 +980,11 @@ class CreateUploadUrlCommand 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("AwsCodeGuruSecurity", "CreateUploadUrl", {})
     .n("CodeGuruSecurityClient", "CreateUploadUrlCommand")
-    .f(void 0, CreateUploadUrlResponseFilterSensitiveLog)
-    .ser(se_CreateUploadUrlCommand)
-    .de(de_CreateUploadUrlCommand)
+    .sc(CreateUploadUrl)
     .build() {
 }
 
@@ -914,16 +992,11 @@ class GetAccountConfigurationCommand 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("AwsCodeGuruSecurity", "GetAccountConfiguration", {})
     .n("CodeGuruSecurityClient", "GetAccountConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetAccountConfigurationCommand)
-    .de(de_GetAccountConfigurationCommand)
+    .sc(GetAccountConfiguration)
     .build() {
 }
 
@@ -931,16 +1004,11 @@ class GetFindingsCommand 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("AwsCodeGuruSecurity", "GetFindings", {})
     .n("CodeGuruSecurityClient", "GetFindingsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetFindingsCommand)
-    .de(de_GetFindingsCommand)
+    .sc(GetFindings)
     .build() {
 }
 
@@ -948,16 +1016,11 @@ class GetMetricsSummaryCommand 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("AwsCodeGuruSecurity", "GetMetricsSummary", {})
     .n("CodeGuruSecurityClient", "GetMetricsSummaryCommand")
-    .f(void 0, void 0)
-    .ser(se_GetMetricsSummaryCommand)
-    .de(de_GetMetricsSummaryCommand)
+    .sc(GetMetricsSummary)
     .build() {
 }
 
@@ -965,16 +1028,11 @@ class GetScanCommand 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("AwsCodeGuruSecurity", "GetScan", {})
     .n("CodeGuruSecurityClient", "GetScanCommand")
-    .f(void 0, void 0)
-    .ser(se_GetScanCommand)
-    .de(de_GetScanCommand)
+    .sc(GetScan)
     .build() {
 }
 
@@ -982,16 +1040,11 @@ class ListFindingsMetricsCommand 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("AwsCodeGuruSecurity", "ListFindingsMetrics", {})
     .n("CodeGuruSecurityClient", "ListFindingsMetricsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListFindingsMetricsCommand)
-    .de(de_ListFindingsMetricsCommand)
+    .sc(ListFindingsMetrics)
     .build() {
 }
 
@@ -999,16 +1052,11 @@ class ListScansCommand 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("AwsCodeGuruSecurity", "ListScans", {})
     .n("CodeGuruSecurityClient", "ListScansCommand")
-    .f(void 0, void 0)
-    .ser(se_ListScansCommand)
-    .de(de_ListScansCommand)
+    .sc(ListScans)
     .build() {
 }
 
@@ -1016,16 +1064,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("AwsCodeGuruSecurity", "ListTagsForResource", {})
     .n("CodeGuruSecurityClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1033,16 +1076,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("AwsCodeGuruSecurity", "TagResource", {})
     .n("CodeGuruSecurityClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1050,16 +1088,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("AwsCodeGuruSecurity", "UntagResource", {})
     .n("CodeGuruSecurityClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1067,16 +1100,11 @@ class UpdateAccountConfigurationCommand 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("AwsCodeGuruSecurity", "UpdateAccountConfiguration", {})
     .n("CodeGuruSecurityClient", "UpdateAccountConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateAccountConfigurationCommand)
-    .de(de_UpdateAccountConfigurationCommand)
+    .sc(UpdateAccountConfiguration)
     .build() {
 }
 
@@ -1113,35 +1141,34 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AnalysisType = AnalysisType;
 exports.BatchGetFindingsCommand = BatchGetFindingsCommand;
 exports.CodeGuruSecurity = CodeGuruSecurity;
 exports.CodeGuruSecurityClient = CodeGuruSecurityClient;
-exports.CodeGuruSecurityServiceException = CodeGuruSecurityServiceException;
-exports.ConflictException = ConflictException;
+exports.CodeGuruSecurityServiceException = CodeGuruSecurityServiceException$1;
+exports.ConflictException = ConflictException$1;
 exports.CreateScanCommand = CreateScanCommand;
 exports.CreateUploadUrlCommand = CreateUploadUrlCommand;
-exports.CreateUploadUrlResponseFilterSensitiveLog = CreateUploadUrlResponseFilterSensitiveLog;
 exports.ErrorCode = ErrorCode;
 exports.GetAccountConfigurationCommand = GetAccountConfigurationCommand;
 exports.GetFindingsCommand = GetFindingsCommand;
 exports.GetMetricsSummaryCommand = GetMetricsSummaryCommand;
 exports.GetScanCommand = GetScanCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListFindingsMetricsCommand = ListFindingsMetricsCommand;
 exports.ListScansCommand = ListScansCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ScanState = ScanState;
 exports.ScanType = ScanType;
 exports.Severity = Severity;
 exports.Status = Status;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateAccountConfigurationCommand = UpdateAccountConfigurationCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.paginateGetFindings = paginateGetFindings;
 exports.paginateListFindingsMetrics = paginateListFindingsMetrics;