@aws-sdk/client-accessanalyzer 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3705 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccessAnalyzerServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AccessAnalyzerClient"), exports);
-tslib_1.__exportStar(require("./AccessAnalyzer"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var AccessAnalyzerServiceException_1 = require("./models/AccessAnalyzerServiceException");
-Object.defineProperty(exports, "AccessAnalyzerServiceException", { enumerable: true, get: function () { return AccessAnalyzerServiceException_1.AccessAnalyzerServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessAnalyzer: () => AccessAnalyzer,
+  AccessAnalyzerClient: () => AccessAnalyzerClient,
+  AccessAnalyzerServiceException: () => AccessAnalyzerServiceException,
+  AccessCheckPolicyType: () => AccessCheckPolicyType,
+  AccessDeniedException: () => AccessDeniedException,
+  AccessPreviewStatus: () => AccessPreviewStatus,
+  AccessPreviewStatusReasonCode: () => AccessPreviewStatusReasonCode,
+  AclGrantee: () => AclGrantee,
+  AclPermission: () => AclPermission,
+  AnalyzerConfiguration: () => AnalyzerConfiguration,
+  ApplyArchiveRuleCommand: () => ApplyArchiveRuleCommand,
+  CancelPolicyGenerationCommand: () => CancelPolicyGenerationCommand,
+  CheckAccessNotGrantedCommand: () => CheckAccessNotGrantedCommand,
+  CheckAccessNotGrantedRequestFilterSensitiveLog: () => CheckAccessNotGrantedRequestFilterSensitiveLog,
+  CheckAccessNotGrantedResult: () => CheckAccessNotGrantedResult,
+  CheckNoNewAccessCommand: () => CheckNoNewAccessCommand,
+  CheckNoNewAccessRequestFilterSensitiveLog: () => CheckNoNewAccessRequestFilterSensitiveLog,
+  CheckNoNewAccessResult: () => CheckNoNewAccessResult,
+  Configuration: () => Configuration,
+  ConflictException: () => ConflictException,
+  CreateAccessPreviewCommand: () => CreateAccessPreviewCommand,
+  CreateAnalyzerCommand: () => CreateAnalyzerCommand,
+  CreateArchiveRuleCommand: () => CreateArchiveRuleCommand,
+  DeleteAnalyzerCommand: () => DeleteAnalyzerCommand,
+  DeleteArchiveRuleCommand: () => DeleteArchiveRuleCommand,
+  FindingChangeType: () => FindingChangeType,
+  FindingDetails: () => FindingDetails,
+  FindingType: () => FindingType,
+  GetAccessPreviewCommand: () => GetAccessPreviewCommand,
+  GetAnalyzedResourceCommand: () => GetAnalyzedResourceCommand,
+  GetAnalyzerCommand: () => GetAnalyzerCommand,
+  GetArchiveRuleCommand: () => GetArchiveRuleCommand,
+  GetFindingCommand: () => GetFindingCommand,
+  GetFindingV2Command: () => GetFindingV2Command,
+  GetGeneratedPolicyCommand: () => GetGeneratedPolicyCommand,
+  InternalServerException: () => InternalServerException,
+  InvalidParameterException: () => InvalidParameterException,
+  JobErrorCode: () => JobErrorCode,
+  JobStatus: () => JobStatus,
+  KmsGrantOperation: () => KmsGrantOperation,
+  ListAccessPreviewFindingsCommand: () => ListAccessPreviewFindingsCommand,
+  ListAccessPreviewsCommand: () => ListAccessPreviewsCommand,
+  ListAnalyzedResourcesCommand: () => ListAnalyzedResourcesCommand,
+  ListAnalyzersCommand: () => ListAnalyzersCommand,
+  ListArchiveRulesCommand: () => ListArchiveRulesCommand,
+  ListFindingsCommand: () => ListFindingsCommand,
+  ListFindingsV2Command: () => ListFindingsV2Command,
+  ListPolicyGenerationsCommand: () => ListPolicyGenerationsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  Locale: () => Locale,
+  NetworkOriginConfiguration: () => NetworkOriginConfiguration,
+  PathElement: () => PathElement,
+  PolicyType: () => PolicyType,
+  RdsDbClusterSnapshotAttributeValue: () => RdsDbClusterSnapshotAttributeValue,
+  RdsDbSnapshotAttributeValue: () => RdsDbSnapshotAttributeValue,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartPolicyGenerationCommand: () => StartPolicyGenerationCommand,
+  StartResourceScanCommand: () => StartResourceScanCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  UnprocessableEntityException: () => UnprocessableEntityException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateArchiveRuleCommand: () => UpdateArchiveRuleCommand,
+  UpdateFindingsCommand: () => UpdateFindingsCommand,
+  ValidatePolicyCommand: () => ValidatePolicyCommand,
+  ValidatePolicyFindingType: () => ValidatePolicyFindingType,
+  ValidatePolicyResourceType: () => ValidatePolicyResourceType,
+  ValidationException: () => ValidationException,
+  ValidationExceptionReason: () => ValidationExceptionReason,
+  __Client: () => import_smithy_client.Client,
+  paginateGetFindingV2: () => paginateGetFindingV2,
+  paginateListAccessPreviewFindings: () => paginateListAccessPreviewFindings,
+  paginateListAccessPreviews: () => paginateListAccessPreviews,
+  paginateListAnalyzedResources: () => paginateListAnalyzedResources,
+  paginateListAnalyzers: () => paginateListAnalyzers,
+  paginateListArchiveRules: () => paginateListArchiveRules,
+  paginateListFindings: () => paginateListFindings,
+  paginateListFindingsV2: () => paginateListFindingsV2,
+  paginateListPolicyGenerations: () => paginateListPolicyGenerations,
+  paginateValidatePolicy: () => paginateValidatePolicy
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AccessAnalyzerClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "access-analyzer"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/AccessAnalyzerClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/AccessAnalyzerClient.ts
+var _AccessAnalyzerClient = class _AccessAnalyzerClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_AccessAnalyzerClient, "AccessAnalyzerClient");
+var AccessAnalyzerClient = _AccessAnalyzerClient;
+
+// src/AccessAnalyzer.ts
+
+
+// src/commands/ApplyArchiveRuleCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/AccessAnalyzerServiceException.ts
+
+var _AccessAnalyzerServiceException = class _AccessAnalyzerServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _AccessAnalyzerServiceException.prototype);
+  }
+};
+__name(_AccessAnalyzerServiceException, "AccessAnalyzerServiceException");
+var AccessAnalyzerServiceException = _AccessAnalyzerServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _ConflictException = class _ConflictException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ThrottlingException = class _ThrottlingException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    this.$retryable = {
+      throttling: true
+    };
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var ValidationExceptionReason = {
+  CANNOT_PARSE: "cannotParse",
+  FIELD_VALIDATION_FAILED: "fieldValidationFailed",
+  OTHER: "other",
+  UNKNOWN_OPERATION: "unknownOperation"
+};
+var _ValidationException = class _ValidationException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.reason = opts.reason;
+    this.fieldList = opts.fieldList;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var AnalyzerConfiguration;
+((AnalyzerConfiguration3) => {
+  AnalyzerConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.unusedAccess !== void 0)
+      return visitor.unusedAccess(value.unusedAccess);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AnalyzerConfiguration || (AnalyzerConfiguration = {}));
+var AccessCheckPolicyType = {
+  IDENTITY_POLICY: "IDENTITY_POLICY",
+  RESOURCE_POLICY: "RESOURCE_POLICY"
+};
+var CheckAccessNotGrantedResult = {
+  FAIL: "FAIL",
+  PASS: "PASS"
+};
+var _InvalidParameterException = class _InvalidParameterException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _UnprocessableEntityException = class _UnprocessableEntityException extends AccessAnalyzerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnprocessableEntityException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnprocessableEntityException";
+    this.$fault = "client";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _UnprocessableEntityException.prototype);
+  }
+};
+__name(_UnprocessableEntityException, "UnprocessableEntityException");
+var UnprocessableEntityException = _UnprocessableEntityException;
+var CheckNoNewAccessResult = {
+  FAIL: "FAIL",
+  PASS: "PASS"
+};
+var KmsGrantOperation = {
+  CREATE_GRANT: "CreateGrant",
+  DECRYPT: "Decrypt",
+  DESCRIBE_KEY: "DescribeKey",
+  ENCRYPT: "Encrypt",
+  GENERATE_DATA_KEY: "GenerateDataKey",
+  GENERATE_DATA_KEY_PAIR: "GenerateDataKeyPair",
+  GENERATE_DATA_KEY_PAIR_WITHOUT_PLAINTEXT: "GenerateDataKeyPairWithoutPlaintext",
+  GENERATE_DATA_KEY_WITHOUT_PLAINTEXT: "GenerateDataKeyWithoutPlaintext",
+  GET_PUBLIC_KEY: "GetPublicKey",
+  REENCRYPT_FROM: "ReEncryptFrom",
+  REENCRYPT_TO: "ReEncryptTo",
+  RETIRE_GRANT: "RetireGrant",
+  SIGN: "Sign",
+  VERIFY: "Verify"
+};
+var RdsDbClusterSnapshotAttributeValue;
+((RdsDbClusterSnapshotAttributeValue3) => {
+  RdsDbClusterSnapshotAttributeValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.accountIds !== void 0)
+      return visitor.accountIds(value.accountIds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RdsDbClusterSnapshotAttributeValue || (RdsDbClusterSnapshotAttributeValue = {}));
+var RdsDbSnapshotAttributeValue;
+((RdsDbSnapshotAttributeValue3) => {
+  RdsDbSnapshotAttributeValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.accountIds !== void 0)
+      return visitor.accountIds(value.accountIds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RdsDbSnapshotAttributeValue || (RdsDbSnapshotAttributeValue = {}));
+var NetworkOriginConfiguration;
+((NetworkOriginConfiguration3) => {
+  NetworkOriginConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.vpcConfiguration !== void 0)
+      return visitor.vpcConfiguration(value.vpcConfiguration);
+    if (value.internetConfiguration !== void 0)
+      return visitor.internetConfiguration(value.internetConfiguration);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(NetworkOriginConfiguration || (NetworkOriginConfiguration = {}));
+var AclGrantee;
+((AclGrantee3) => {
+  AclGrantee3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.id !== void 0)
+      return visitor.id(value.id);
+    if (value.uri !== void 0)
+      return visitor.uri(value.uri);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AclGrantee || (AclGrantee = {}));
+var AclPermission = {
+  FULL_CONTROL: "FULL_CONTROL",
+  READ: "READ",
+  READ_ACP: "READ_ACP",
+  WRITE: "WRITE",
+  WRITE_ACP: "WRITE_ACP"
+};
+var Configuration;
+((Configuration3) => {
+  Configuration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ebsSnapshot !== void 0)
+      return visitor.ebsSnapshot(value.ebsSnapshot);
+    if (value.ecrRepository !== void 0)
+      return visitor.ecrRepository(value.ecrRepository);
+    if (value.iamRole !== void 0)
+      return visitor.iamRole(value.iamRole);
+    if (value.efsFileSystem !== void 0)
+      return visitor.efsFileSystem(value.efsFileSystem);
+    if (value.kmsKey !== void 0)
+      return visitor.kmsKey(value.kmsKey);
+    if (value.rdsDbClusterSnapshot !== void 0)
+      return visitor.rdsDbClusterSnapshot(value.rdsDbClusterSnapshot);
+    if (value.rdsDbSnapshot !== void 0)
+      return visitor.rdsDbSnapshot(value.rdsDbSnapshot);
+    if (value.secretsManagerSecret !== void 0)
+      return visitor.secretsManagerSecret(value.secretsManagerSecret);
+    if (value.s3Bucket !== void 0)
+      return visitor.s3Bucket(value.s3Bucket);
+    if (value.snsTopic !== void 0)
+      return visitor.snsTopic(value.snsTopic);
+    if (value.sqsQueue !== void 0)
+      return visitor.sqsQueue(value.sqsQueue);
+    if (value.s3ExpressDirectoryBucket !== void 0)
+      return visitor.s3ExpressDirectoryBucket(value.s3ExpressDirectoryBucket);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Configuration || (Configuration = {}));
+var AccessPreviewStatus = {
+  COMPLETED: "COMPLETED",
+  CREATING: "CREATING",
+  FAILED: "FAILED"
+};
+var AccessPreviewStatusReasonCode = {
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  INVALID_CONFIGURATION: "INVALID_CONFIGURATION"
+};
+var FindingDetails;
+((FindingDetails3) => {
+  FindingDetails3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.externalAccessDetails !== void 0)
+      return visitor.externalAccessDetails(value.externalAccessDetails);
+    if (value.unusedPermissionDetails !== void 0)
+      return visitor.unusedPermissionDetails(value.unusedPermissionDetails);
+    if (value.unusedIamUserAccessKeyDetails !== void 0)
+      return visitor.unusedIamUserAccessKeyDetails(value.unusedIamUserAccessKeyDetails);
+    if (value.unusedIamRoleDetails !== void 0)
+      return visitor.unusedIamRoleDetails(value.unusedIamRoleDetails);
+    if (value.unusedIamUserPasswordDetails !== void 0)
+      return visitor.unusedIamUserPasswordDetails(value.unusedIamUserPasswordDetails);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FindingDetails || (FindingDetails = {}));
+var FindingType = {
+  EXTERNAL_ACCESS: "ExternalAccess",
+  UNUSED_IAM_ROLE: "UnusedIAMRole",
+  UNUSED_IAM_USER_ACCESS_KEY: "UnusedIAMUserAccessKey",
+  UNUSED_IAM_USER_PASSWORD: "UnusedIAMUserPassword",
+  UNUSED_PERMISSION: "UnusedPermission"
+};
+var JobErrorCode = {
+  AUTHORIZATION_ERROR: "AUTHORIZATION_ERROR",
+  RESOURCE_NOT_FOUND_ERROR: "RESOURCE_NOT_FOUND_ERROR",
+  SERVICE_ERROR: "SERVICE_ERROR",
+  SERVICE_QUOTA_EXCEEDED_ERROR: "SERVICE_QUOTA_EXCEEDED_ERROR"
+};
+var JobStatus = {
+  CANCELED: "CANCELED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var FindingChangeType = {
+  CHANGED: "CHANGED",
+  NEW: "NEW",
+  UNCHANGED: "UNCHANGED"
+};
+var Locale = {
+  DE: "DE",
+  EN: "EN",
+  ES: "ES",
+  FR: "FR",
+  IT: "IT",
+  JA: "JA",
+  KO: "KO",
+  PT_BR: "PT_BR",
+  ZH_CN: "ZH_CN",
+  ZH_TW: "ZH_TW"
+};
+var PolicyType = {
+  IDENTITY_POLICY: "IDENTITY_POLICY",
+  RESOURCE_POLICY: "RESOURCE_POLICY",
+  SERVICE_CONTROL_POLICY: "SERVICE_CONTROL_POLICY"
+};
+var ValidatePolicyResourceType = {
+  ROLE_TRUST: "AWS::IAM::AssumeRolePolicyDocument",
+  S3_ACCESS_POINT: "AWS::S3::AccessPoint",
+  S3_BUCKET: "AWS::S3::Bucket",
+  S3_MULTI_REGION_ACCESS_POINT: "AWS::S3::MultiRegionAccessPoint",
+  S3_OBJECT_LAMBDA_ACCESS_POINT: "AWS::S3ObjectLambda::AccessPoint"
+};
+var ValidatePolicyFindingType = {
+  ERROR: "ERROR",
+  SECURITY_WARNING: "SECURITY_WARNING",
+  SUGGESTION: "SUGGESTION",
+  WARNING: "WARNING"
+};
+var PathElement;
+((PathElement2) => {
+  PathElement2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.index !== void 0)
+      return visitor.index(value.index);
+    if (value.key !== void 0)
+      return visitor.key(value.key);
+    if (value.substring !== void 0)
+      return visitor.substring(value.substring);
+    if (value.value !== void 0)
+      return visitor.value(value.value);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(PathElement || (PathElement = {}));
+var CheckAccessNotGrantedRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.policyDocument && { policyDocument: import_smithy_client.SENSITIVE_STRING }
+}), "CheckAccessNotGrantedRequestFilterSensitiveLog");
+var CheckNoNewAccessRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.newPolicyDocument && { newPolicyDocument: import_smithy_client.SENSITIVE_STRING },
+  ...obj.existingPolicyDocument && { existingPolicyDocument: import_smithy_client.SENSITIVE_STRING }
+}), "CheckNoNewAccessRequestFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_ApplyArchiveRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/archive-rule");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ruleName: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_ApplyArchiveRuleCommand");
+var se_CancelPolicyGenerationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/policy/generation/{jobId}");
+  b.p("jobId", () => input.jobId, "{jobId}", false);
+  let body;
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CancelPolicyGenerationCommand");
+var se_CheckAccessNotGrantedCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/policy/check-access-not-granted");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      access: (_) => (0, import_smithy_client._json)(_),
+      policyDocument: [],
+      policyType: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CheckAccessNotGrantedCommand");
+var se_CheckNoNewAccessCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/policy/check-no-new-access");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      existingPolicyDocument: [],
+      newPolicyDocument: [],
+      policyType: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CheckNoNewAccessCommand");
+var se_CreateAccessPreviewCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/access-preview");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      configurations: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateAccessPreviewCommand");
+var se_CreateAnalyzerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/analyzer");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerName: [],
+      archiveRules: (_) => (0, import_smithy_client._json)(_),
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      configuration: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      type: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateAnalyzerCommand");
+var se_CreateArchiveRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/analyzer/{analyzerName}/archive-rule");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      filter: (_) => (0, import_smithy_client._json)(_),
+      ruleName: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateArchiveRuleCommand");
+var se_DeleteAnalyzerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer/{analyzerName}");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_cT]: [, input[_cT] ?? (0, import_uuid.v4)()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteAnalyzerCommand");
+var se_DeleteArchiveRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer/{analyzerName}/archive-rule/{ruleName}");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  b.p("ruleName", () => input.ruleName, "{ruleName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_cT]: [, input[_cT] ?? (0, import_uuid.v4)()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteArchiveRuleCommand");
+var se_GetAccessPreviewCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/access-preview/{accessPreviewId}");
+  b.p("accessPreviewId", () => input.accessPreviewId, "{accessPreviewId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_aA]: [, (0, import_smithy_client.expectNonNull)(input[_aA], `analyzerArn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetAccessPreviewCommand");
+var se_GetAnalyzedResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzed-resource");
+  const query = (0, import_smithy_client.map)({
+    [_aA]: [, (0, import_smithy_client.expectNonNull)(input[_aA], `analyzerArn`)],
+    [_rA]: [, (0, import_smithy_client.expectNonNull)(input[_rA], `resourceArn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetAnalyzedResourceCommand");
+var se_GetAnalyzerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer/{analyzerName}");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetAnalyzerCommand");
+var se_GetArchiveRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer/{analyzerName}/archive-rule/{ruleName}");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  b.p("ruleName", () => input.ruleName, "{ruleName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetArchiveRuleCommand");
+var se_GetFindingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/finding/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  const query = (0, import_smithy_client.map)({
+    [_aA]: [, (0, import_smithy_client.expectNonNull)(input[_aA], `analyzerArn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetFindingCommand");
+var se_GetFindingV2Command = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/findingv2/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  const query = (0, import_smithy_client.map)({
+    [_aA]: [, (0, import_smithy_client.expectNonNull)(input[_aA], `analyzerArn`)],
+    [_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();
+}, "se_GetFindingV2Command");
+var se_GetGeneratedPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/policy/generation/{jobId}");
+  b.p("jobId", () => input.jobId, "{jobId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_iRP]: [() => input.includeResourcePlaceholders !== void 0, () => input[_iRP].toString()],
+    [_iSLT]: [() => input.includeServiceLevelTemplate !== void 0, () => input[_iSLT].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetGeneratedPolicyCommand");
+var se_ListAccessPreviewFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/access-preview/{accessPreviewId}");
+  b.p("accessPreviewId", () => input.accessPreviewId, "{accessPreviewId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      filter: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListAccessPreviewFindingsCommand");
+var se_ListAccessPreviewsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/access-preview");
+  const query = (0, import_smithy_client.map)({
+    [_aA]: [, (0, import_smithy_client.expectNonNull)(input[_aA], `analyzerArn`)],
+    [_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();
+}, "se_ListAccessPreviewsCommand");
+var se_ListAnalyzedResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/analyzed-resource");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      maxResults: [],
+      nextToken: [],
+      resourceType: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListAnalyzedResourcesCommand");
+var se_ListAnalyzersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer");
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_t]: [, input[_t]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListAnalyzersCommand");
+var se_ListArchiveRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/analyzer/{analyzerName}/archive-rule");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  const query = (0, import_smithy_client.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();
+}, "se_ListArchiveRulesCommand");
+var se_ListFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/finding");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      filter: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: [],
+      sort: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListFindingsCommand");
+var se_ListFindingsV2Command = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/findingv2");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      filter: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: [],
+      sort: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListFindingsV2Command");
+var se_ListPolicyGenerationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/policy/generation");
+  const query = (0, import_smithy_client.map)({
+    [_pA]: [, input[_pA]],
+    [_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();
+}, "se_ListPolicyGenerationsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_StartPolicyGenerationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/policy/generation");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      cloudTrailDetails: (_) => se_CloudTrailDetails(_, context),
+      policyGenerationDetails: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_StartPolicyGenerationCommand");
+var se_StartResourceScanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resource/scan");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      resourceArn: [],
+      resourceOwnerAccount: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartResourceScanCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateArchiveRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/analyzer/{analyzerName}/archive-rule/{ruleName}");
+  b.p("analyzerName", () => input.analyzerName, "{analyzerName}", false);
+  b.p("ruleName", () => input.ruleName, "{ruleName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      filter: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateArchiveRuleCommand");
+var se_UpdateFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/finding");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      analyzerArn: [],
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ids: (_) => (0, import_smithy_client._json)(_),
+      resourceArn: [],
+      status: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFindingsCommand");
+var se_ValidatePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/policy/validation");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      locale: [],
+      policyDocument: [],
+      policyType: [],
+      validatePolicyResourceType: []
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ValidatePolicyCommand");
+var de_ApplyArchiveRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ApplyArchiveRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_ApplyArchiveRuleCommand");
+var de_ApplyArchiveRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ApplyArchiveRuleCommandError");
+var de_CancelPolicyGenerationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CancelPolicyGenerationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CancelPolicyGenerationCommand");
+var de_CancelPolicyGenerationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CancelPolicyGenerationCommandError");
+var de_CheckAccessNotGrantedCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CheckAccessNotGrantedCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    reasons: import_smithy_client._json,
+    result: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CheckAccessNotGrantedCommand");
+var de_CheckAccessNotGrantedCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.accessanalyzer#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnprocessableEntityException":
+    case "com.amazonaws.accessanalyzer#UnprocessableEntityException":
+      throw await de_UnprocessableEntityExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CheckAccessNotGrantedCommandError");
+var de_CheckNoNewAccessCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CheckNoNewAccessCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    reasons: import_smithy_client._json,
+    result: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CheckNoNewAccessCommand");
+var de_CheckNoNewAccessCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.accessanalyzer#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnprocessableEntityException":
+    case "com.amazonaws.accessanalyzer#UnprocessableEntityException":
+      throw await de_UnprocessableEntityExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CheckNoNewAccessCommandError");
+var de_CreateAccessPreviewCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateAccessPreviewCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    id: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateAccessPreviewCommand");
+var de_CreateAccessPreviewCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.accessanalyzer#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.accessanalyzer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAccessPreviewCommandError");
+var de_CreateAnalyzerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateAnalyzerCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateAnalyzerCommand");
+var de_CreateAnalyzerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.accessanalyzer#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.accessanalyzer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAnalyzerCommandError");
+var de_CreateArchiveRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateArchiveRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateArchiveRuleCommand");
+var de_CreateArchiveRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.accessanalyzer#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.accessanalyzer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateArchiveRuleCommandError");
+var de_DeleteAnalyzerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteAnalyzerCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteAnalyzerCommand");
+var de_DeleteAnalyzerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAnalyzerCommandError");
+var de_DeleteArchiveRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteArchiveRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteArchiveRuleCommand");
+var de_DeleteArchiveRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteArchiveRuleCommandError");
+var de_GetAccessPreviewCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetAccessPreviewCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    accessPreview: (_) => de_AccessPreview(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetAccessPreviewCommand");
+var de_GetAccessPreviewCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccessPreviewCommandError");
+var de_GetAnalyzedResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetAnalyzedResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    resource: (_) => de_AnalyzedResource(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetAnalyzedResourceCommand");
+var de_GetAnalyzedResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAnalyzedResourceCommandError");
+var de_GetAnalyzerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetAnalyzerCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    analyzer: (_) => de_AnalyzerSummary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetAnalyzerCommand");
+var de_GetAnalyzerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAnalyzerCommandError");
+var de_GetArchiveRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetArchiveRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    archiveRule: (_) => de_ArchiveRuleSummary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetArchiveRuleCommand");
+var de_GetArchiveRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetArchiveRuleCommandError");
+var de_GetFindingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetFindingCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    finding: (_) => de_Finding(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetFindingCommand");
+var de_GetFindingCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetFindingCommandError");
+var de_GetFindingV2Command = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetFindingV2CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    analyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    findingDetails: (_) => de_FindingDetailsList(_, context),
+    findingType: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    nextToken: import_smithy_client.expectString,
+    resource: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetFindingV2Command");
+var de_GetFindingV2CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetFindingV2CommandError");
+var de_GetGeneratedPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGeneratedPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    generatedPolicyResult: (_) => de_GeneratedPolicyResult(_, context),
+    jobDetails: (_) => de_JobDetails(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGeneratedPolicyCommand");
+var de_GetGeneratedPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGeneratedPolicyCommandError");
+var de_ListAccessPreviewFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAccessPreviewFindingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    findings: (_) => de_AccessPreviewFindingsList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAccessPreviewFindingsCommand");
+var de_ListAccessPreviewFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.accessanalyzer#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAccessPreviewFindingsCommandError");
+var de_ListAccessPreviewsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAccessPreviewsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    accessPreviews: (_) => de_AccessPreviewsList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAccessPreviewsCommand");
+var de_ListAccessPreviewsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAccessPreviewsCommandError");
+var de_ListAnalyzedResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAnalyzedResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    analyzedResources: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAnalyzedResourcesCommand");
+var de_ListAnalyzedResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAnalyzedResourcesCommandError");
+var de_ListAnalyzersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAnalyzersCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    analyzers: (_) => de_AnalyzersList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAnalyzersCommand");
+var de_ListAnalyzersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAnalyzersCommandError");
+var de_ListArchiveRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListArchiveRulesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    archiveRules: (_) => de_ArchiveRulesList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListArchiveRulesCommand");
+var de_ListArchiveRulesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListArchiveRulesCommandError");
+var de_ListFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListFindingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    findings: (_) => de_FindingsList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFindingsCommand");
+var de_ListFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFindingsCommandError");
+var de_ListFindingsV2Command = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListFindingsV2CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    findings: (_) => de_FindingsListV2(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListFindingsV2Command");
+var de_ListFindingsV2CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFindingsV2CommandError");
+var de_ListPolicyGenerationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListPolicyGenerationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    policyGenerations: (_) => de_PolicyGenerationList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPolicyGenerationsCommand");
+var de_ListPolicyGenerationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPolicyGenerationsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartPolicyGenerationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartPolicyGenerationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    jobId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartPolicyGenerationCommand");
+var de_StartPolicyGenerationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.accessanalyzer#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.accessanalyzer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartPolicyGenerationCommandError");
+var de_StartResourceScanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartResourceScanCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StartResourceScanCommand");
+var de_StartResourceScanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartResourceScanCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateArchiveRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateArchiveRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateArchiveRuleCommand");
+var de_UpdateArchiveRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateArchiveRuleCommandError");
+var de_UpdateFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateFindingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateFindingsCommand");
+var de_UpdateFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.accessanalyzer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFindingsCommandError");
+var de_ValidatePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ValidatePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    findings: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ValidatePolicyCommand");
+var de_ValidatePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.accessanalyzer#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.accessanalyzer#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.accessanalyzer#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.accessanalyzer#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ValidatePolicyCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(AccessAnalyzerServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidParameterExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_UnprocessableEntityExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnprocessableEntityException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnprocessableEntityExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    fieldList: import_smithy_client._json,
+    message: import_smithy_client.expectString,
+    reason: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_CloudTrailDetails = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    accessRole: [],
+    endTime: (_) => _.toISOString().split(".")[0] + "Z",
+    startTime: (_) => _.toISOString().split(".")[0] + "Z",
+    trails: import_smithy_client._json
+  });
+}, "se_CloudTrailDetails");
+var de_AccessPreview = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    analyzerArn: import_smithy_client.expectString,
+    configurations: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    id: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client._json
+  });
+}, "de_AccessPreview");
+var de_AccessPreviewFinding = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client._json,
+    changeType: import_smithy_client.expectString,
+    condition: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    existingFindingId: import_smithy_client.expectString,
+    existingFindingStatus: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    isPublic: import_smithy_client.expectBoolean,
+    principal: import_smithy_client._json,
+    resource: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    sources: import_smithy_client._json,
+    status: import_smithy_client.expectString
+  });
+}, "de_AccessPreviewFinding");
+var de_AccessPreviewFindingsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AccessPreviewFinding(entry, context);
+  });
+  return retVal;
+}, "de_AccessPreviewFindingsList");
+var de_AccessPreviewsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AccessPreviewSummary(entry, context);
+  });
+  return retVal;
+}, "de_AccessPreviewsList");
+var de_AccessPreviewSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    analyzerArn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    id: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client._json
+  });
+}, "de_AccessPreviewSummary");
+var de_AnalyzedResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actions: import_smithy_client._json,
+    analyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    isPublic: import_smithy_client.expectBoolean,
+    resourceArn: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    sharedVia: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_AnalyzedResource");
+var de_AnalyzersList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AnalyzerSummary(entry, context);
+  });
+  return retVal;
+}, "de_AnalyzersList");
+var de_AnalyzerSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    configuration: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    lastResourceAnalyzed: import_smithy_client.expectString,
+    lastResourceAnalyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    name: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_AnalyzerSummary");
+var de_ArchiveRulesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ArchiveRuleSummary(entry, context);
+  });
+  return retVal;
+}, "de_ArchiveRulesList");
+var de_ArchiveRuleSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    filter: import_smithy_client._json,
+    ruleName: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_ArchiveRuleSummary");
+var de_CloudTrailProperties = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    trailProperties: import_smithy_client._json
+  });
+}, "de_CloudTrailProperties");
+var de_Finding = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client._json,
+    analyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    condition: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    isPublic: import_smithy_client.expectBoolean,
+    principal: import_smithy_client._json,
+    resource: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    sources: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_Finding");
+var de_FindingDetails = /* @__PURE__ */ __name((output, context) => {
+  if (output.externalAccessDetails != null) {
+    return {
+      externalAccessDetails: (0, import_smithy_client._json)(output.externalAccessDetails)
+    };
+  }
+  if (output.unusedIamRoleDetails != null) {
+    return {
+      unusedIamRoleDetails: de_UnusedIamRoleDetails(output.unusedIamRoleDetails, context)
+    };
+  }
+  if (output.unusedIamUserAccessKeyDetails != null) {
+    return {
+      unusedIamUserAccessKeyDetails: de_UnusedIamUserAccessKeyDetails(output.unusedIamUserAccessKeyDetails, context)
+    };
+  }
+  if (output.unusedIamUserPasswordDetails != null) {
+    return {
+      unusedIamUserPasswordDetails: de_UnusedIamUserPasswordDetails(output.unusedIamUserPasswordDetails, context)
+    };
+  }
+  if (output.unusedPermissionDetails != null) {
+    return {
+      unusedPermissionDetails: de_UnusedPermissionDetails(output.unusedPermissionDetails, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FindingDetails");
+var de_FindingDetailsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FindingDetails((0, import_core.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_FindingDetailsList");
+var de_FindingsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FindingSummary(entry, context);
+  });
+  return retVal;
+}, "de_FindingsList");
+var de_FindingsListV2 = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FindingSummaryV2(entry, context);
+  });
+  return retVal;
+}, "de_FindingsListV2");
+var de_FindingSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client._json,
+    analyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    condition: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    isPublic: import_smithy_client.expectBoolean,
+    principal: import_smithy_client._json,
+    resource: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    sources: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FindingSummary");
+var de_FindingSummaryV2 = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    analyzedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    error: import_smithy_client.expectString,
+    findingType: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    resource: import_smithy_client.expectString,
+    resourceOwnerAccount: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_FindingSummaryV2");
+var de_GeneratedPolicyProperties = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    cloudTrailProperties: (_) => de_CloudTrailProperties(_, context),
+    isComplete: import_smithy_client.expectBoolean,
+    principalArn: import_smithy_client.expectString
+  });
+}, "de_GeneratedPolicyProperties");
+var de_GeneratedPolicyResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    generatedPolicies: import_smithy_client._json,
+    properties: (_) => de_GeneratedPolicyProperties(_, context)
+  });
+}, "de_GeneratedPolicyResult");
+var de_JobDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    completedOn: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    jobError: import_smithy_client._json,
+    jobId: import_smithy_client.expectString,
+    startedOn: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    status: import_smithy_client.expectString
+  });
+}, "de_JobDetails");
+var de_PolicyGeneration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    completedOn: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    jobId: import_smithy_client.expectString,
+    principalArn: import_smithy_client.expectString,
+    startedOn: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    status: import_smithy_client.expectString
+  });
+}, "de_PolicyGeneration");
+var de_PolicyGenerationList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_PolicyGeneration(entry, context);
+  });
+  return retVal;
+}, "de_PolicyGenerationList");
+var de_UnusedAction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client.expectString,
+    lastAccessed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_UnusedAction");
+var de_UnusedActionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_UnusedAction(entry, context);
+  });
+  return retVal;
+}, "de_UnusedActionList");
+var de_UnusedIamRoleDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastAccessed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_UnusedIamRoleDetails");
+var de_UnusedIamUserAccessKeyDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    accessKeyId: import_smithy_client.expectString,
+    lastAccessed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_UnusedIamUserAccessKeyDetails");
+var de_UnusedIamUserPasswordDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastAccessed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_UnusedIamUserPasswordDetails");
+var de_UnusedPermissionDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actions: (_) => de_UnusedActionList(_, context),
+    lastAccessed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    serviceNamespace: import_smithy_client.expectString
+  });
+}, "de_UnusedPermissionDetails");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _aA = "analyzerArn";
+var _cT = "clientToken";
+var _iRP = "includeResourcePlaceholders";
+var _iSLT = "includeServiceLevelTemplate";
+var _mR = "maxResults";
+var _nT = "nextToken";
+var _pA = "principalArn";
+var _rA = "resourceArn";
+var _rAS = "retryAfterSeconds";
+var _ra = "retry-after";
+var _t = "type";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/ApplyArchiveRuleCommand.ts
+var _ApplyArchiveRuleCommand = class _ApplyArchiveRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ApplyArchiveRule", {}).n("AccessAnalyzerClient", "ApplyArchiveRuleCommand").f(void 0, void 0).ser(se_ApplyArchiveRuleCommand).de(de_ApplyArchiveRuleCommand).build() {
+};
+__name(_ApplyArchiveRuleCommand, "ApplyArchiveRuleCommand");
+var ApplyArchiveRuleCommand = _ApplyArchiveRuleCommand;
+
+// src/commands/CancelPolicyGenerationCommand.ts
+
+
+
+
+var _CancelPolicyGenerationCommand = class _CancelPolicyGenerationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CancelPolicyGeneration", {}).n("AccessAnalyzerClient", "CancelPolicyGenerationCommand").f(void 0, void 0).ser(se_CancelPolicyGenerationCommand).de(de_CancelPolicyGenerationCommand).build() {
+};
+__name(_CancelPolicyGenerationCommand, "CancelPolicyGenerationCommand");
+var CancelPolicyGenerationCommand = _CancelPolicyGenerationCommand;
+
+// src/commands/CheckAccessNotGrantedCommand.ts
+
+
+
+
+var _CheckAccessNotGrantedCommand = class _CheckAccessNotGrantedCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CheckAccessNotGranted", {}).n("AccessAnalyzerClient", "CheckAccessNotGrantedCommand").f(CheckAccessNotGrantedRequestFilterSensitiveLog, void 0).ser(se_CheckAccessNotGrantedCommand).de(de_CheckAccessNotGrantedCommand).build() {
+};
+__name(_CheckAccessNotGrantedCommand, "CheckAccessNotGrantedCommand");
+var CheckAccessNotGrantedCommand = _CheckAccessNotGrantedCommand;
+
+// src/commands/CheckNoNewAccessCommand.ts
+
+
+
+
+var _CheckNoNewAccessCommand = class _CheckNoNewAccessCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CheckNoNewAccess", {}).n("AccessAnalyzerClient", "CheckNoNewAccessCommand").f(CheckNoNewAccessRequestFilterSensitiveLog, void 0).ser(se_CheckNoNewAccessCommand).de(de_CheckNoNewAccessCommand).build() {
+};
+__name(_CheckNoNewAccessCommand, "CheckNoNewAccessCommand");
+var CheckNoNewAccessCommand = _CheckNoNewAccessCommand;
+
+// src/commands/CreateAccessPreviewCommand.ts
+
+
+
+
+var _CreateAccessPreviewCommand = class _CreateAccessPreviewCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CreateAccessPreview", {}).n("AccessAnalyzerClient", "CreateAccessPreviewCommand").f(void 0, void 0).ser(se_CreateAccessPreviewCommand).de(de_CreateAccessPreviewCommand).build() {
+};
+__name(_CreateAccessPreviewCommand, "CreateAccessPreviewCommand");
+var CreateAccessPreviewCommand = _CreateAccessPreviewCommand;
+
+// src/commands/CreateAnalyzerCommand.ts
+
+
+
+
+var _CreateAnalyzerCommand = class _CreateAnalyzerCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CreateAnalyzer", {}).n("AccessAnalyzerClient", "CreateAnalyzerCommand").f(void 0, void 0).ser(se_CreateAnalyzerCommand).de(de_CreateAnalyzerCommand).build() {
+};
+__name(_CreateAnalyzerCommand, "CreateAnalyzerCommand");
+var CreateAnalyzerCommand = _CreateAnalyzerCommand;
+
+// src/commands/CreateArchiveRuleCommand.ts
+
+
+
+
+var _CreateArchiveRuleCommand = class _CreateArchiveRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "CreateArchiveRule", {}).n("AccessAnalyzerClient", "CreateArchiveRuleCommand").f(void 0, void 0).ser(se_CreateArchiveRuleCommand).de(de_CreateArchiveRuleCommand).build() {
+};
+__name(_CreateArchiveRuleCommand, "CreateArchiveRuleCommand");
+var CreateArchiveRuleCommand = _CreateArchiveRuleCommand;
+
+// src/commands/DeleteAnalyzerCommand.ts
+
+
+
+
+var _DeleteAnalyzerCommand = class _DeleteAnalyzerCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "DeleteAnalyzer", {}).n("AccessAnalyzerClient", "DeleteAnalyzerCommand").f(void 0, void 0).ser(se_DeleteAnalyzerCommand).de(de_DeleteAnalyzerCommand).build() {
+};
+__name(_DeleteAnalyzerCommand, "DeleteAnalyzerCommand");
+var DeleteAnalyzerCommand = _DeleteAnalyzerCommand;
+
+// src/commands/DeleteArchiveRuleCommand.ts
+
+
+
+
+var _DeleteArchiveRuleCommand = class _DeleteArchiveRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "DeleteArchiveRule", {}).n("AccessAnalyzerClient", "DeleteArchiveRuleCommand").f(void 0, void 0).ser(se_DeleteArchiveRuleCommand).de(de_DeleteArchiveRuleCommand).build() {
+};
+__name(_DeleteArchiveRuleCommand, "DeleteArchiveRuleCommand");
+var DeleteArchiveRuleCommand = _DeleteArchiveRuleCommand;
+
+// src/commands/GetAccessPreviewCommand.ts
+
+
+
+
+var _GetAccessPreviewCommand = class _GetAccessPreviewCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetAccessPreview", {}).n("AccessAnalyzerClient", "GetAccessPreviewCommand").f(void 0, void 0).ser(se_GetAccessPreviewCommand).de(de_GetAccessPreviewCommand).build() {
+};
+__name(_GetAccessPreviewCommand, "GetAccessPreviewCommand");
+var GetAccessPreviewCommand = _GetAccessPreviewCommand;
+
+// src/commands/GetAnalyzedResourceCommand.ts
+
+
+
+
+var _GetAnalyzedResourceCommand = class _GetAnalyzedResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetAnalyzedResource", {}).n("AccessAnalyzerClient", "GetAnalyzedResourceCommand").f(void 0, void 0).ser(se_GetAnalyzedResourceCommand).de(de_GetAnalyzedResourceCommand).build() {
+};
+__name(_GetAnalyzedResourceCommand, "GetAnalyzedResourceCommand");
+var GetAnalyzedResourceCommand = _GetAnalyzedResourceCommand;
+
+// src/commands/GetAnalyzerCommand.ts
+
+
+
+
+var _GetAnalyzerCommand = class _GetAnalyzerCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetAnalyzer", {}).n("AccessAnalyzerClient", "GetAnalyzerCommand").f(void 0, void 0).ser(se_GetAnalyzerCommand).de(de_GetAnalyzerCommand).build() {
+};
+__name(_GetAnalyzerCommand, "GetAnalyzerCommand");
+var GetAnalyzerCommand = _GetAnalyzerCommand;
+
+// src/commands/GetArchiveRuleCommand.ts
+
+
+
+
+var _GetArchiveRuleCommand = class _GetArchiveRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetArchiveRule", {}).n("AccessAnalyzerClient", "GetArchiveRuleCommand").f(void 0, void 0).ser(se_GetArchiveRuleCommand).de(de_GetArchiveRuleCommand).build() {
+};
+__name(_GetArchiveRuleCommand, "GetArchiveRuleCommand");
+var GetArchiveRuleCommand = _GetArchiveRuleCommand;
+
+// src/commands/GetFindingCommand.ts
+
+
+
+
+var _GetFindingCommand = class _GetFindingCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetFinding", {}).n("AccessAnalyzerClient", "GetFindingCommand").f(void 0, void 0).ser(se_GetFindingCommand).de(de_GetFindingCommand).build() {
+};
+__name(_GetFindingCommand, "GetFindingCommand");
+var GetFindingCommand = _GetFindingCommand;
+
+// src/commands/GetFindingV2Command.ts
+
+
+
+
+var _GetFindingV2Command = class _GetFindingV2Command extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetFindingV2", {}).n("AccessAnalyzerClient", "GetFindingV2Command").f(void 0, void 0).ser(se_GetFindingV2Command).de(de_GetFindingV2Command).build() {
+};
+__name(_GetFindingV2Command, "GetFindingV2Command");
+var GetFindingV2Command = _GetFindingV2Command;
+
+// src/commands/GetGeneratedPolicyCommand.ts
+
+
+
+
+var _GetGeneratedPolicyCommand = class _GetGeneratedPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "GetGeneratedPolicy", {}).n("AccessAnalyzerClient", "GetGeneratedPolicyCommand").f(void 0, void 0).ser(se_GetGeneratedPolicyCommand).de(de_GetGeneratedPolicyCommand).build() {
+};
+__name(_GetGeneratedPolicyCommand, "GetGeneratedPolicyCommand");
+var GetGeneratedPolicyCommand = _GetGeneratedPolicyCommand;
+
+// src/commands/ListAccessPreviewFindingsCommand.ts
+
+
+
+
+var _ListAccessPreviewFindingsCommand = class _ListAccessPreviewFindingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListAccessPreviewFindings", {}).n("AccessAnalyzerClient", "ListAccessPreviewFindingsCommand").f(void 0, void 0).ser(se_ListAccessPreviewFindingsCommand).de(de_ListAccessPreviewFindingsCommand).build() {
+};
+__name(_ListAccessPreviewFindingsCommand, "ListAccessPreviewFindingsCommand");
+var ListAccessPreviewFindingsCommand = _ListAccessPreviewFindingsCommand;
+
+// src/commands/ListAccessPreviewsCommand.ts
+
+
+
+
+var _ListAccessPreviewsCommand = class _ListAccessPreviewsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListAccessPreviews", {}).n("AccessAnalyzerClient", "ListAccessPreviewsCommand").f(void 0, void 0).ser(se_ListAccessPreviewsCommand).de(de_ListAccessPreviewsCommand).build() {
+};
+__name(_ListAccessPreviewsCommand, "ListAccessPreviewsCommand");
+var ListAccessPreviewsCommand = _ListAccessPreviewsCommand;
+
+// src/commands/ListAnalyzedResourcesCommand.ts
+
+
+
+
+var _ListAnalyzedResourcesCommand = class _ListAnalyzedResourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListAnalyzedResources", {}).n("AccessAnalyzerClient", "ListAnalyzedResourcesCommand").f(void 0, void 0).ser(se_ListAnalyzedResourcesCommand).de(de_ListAnalyzedResourcesCommand).build() {
+};
+__name(_ListAnalyzedResourcesCommand, "ListAnalyzedResourcesCommand");
+var ListAnalyzedResourcesCommand = _ListAnalyzedResourcesCommand;
+
+// src/commands/ListAnalyzersCommand.ts
+
+
+
+
+var _ListAnalyzersCommand = class _ListAnalyzersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListAnalyzers", {}).n("AccessAnalyzerClient", "ListAnalyzersCommand").f(void 0, void 0).ser(se_ListAnalyzersCommand).de(de_ListAnalyzersCommand).build() {
+};
+__name(_ListAnalyzersCommand, "ListAnalyzersCommand");
+var ListAnalyzersCommand = _ListAnalyzersCommand;
+
+// src/commands/ListArchiveRulesCommand.ts
+
+
+
+
+var _ListArchiveRulesCommand = class _ListArchiveRulesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListArchiveRules", {}).n("AccessAnalyzerClient", "ListArchiveRulesCommand").f(void 0, void 0).ser(se_ListArchiveRulesCommand).de(de_ListArchiveRulesCommand).build() {
+};
+__name(_ListArchiveRulesCommand, "ListArchiveRulesCommand");
+var ListArchiveRulesCommand = _ListArchiveRulesCommand;
+
+// src/commands/ListFindingsCommand.ts
+
+
+
+
+var _ListFindingsCommand = class _ListFindingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListFindings", {}).n("AccessAnalyzerClient", "ListFindingsCommand").f(void 0, void 0).ser(se_ListFindingsCommand).de(de_ListFindingsCommand).build() {
+};
+__name(_ListFindingsCommand, "ListFindingsCommand");
+var ListFindingsCommand = _ListFindingsCommand;
+
+// src/commands/ListFindingsV2Command.ts
+
+
+
+
+var _ListFindingsV2Command = class _ListFindingsV2Command extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListFindingsV2", {}).n("AccessAnalyzerClient", "ListFindingsV2Command").f(void 0, void 0).ser(se_ListFindingsV2Command).de(de_ListFindingsV2Command).build() {
+};
+__name(_ListFindingsV2Command, "ListFindingsV2Command");
+var ListFindingsV2Command = _ListFindingsV2Command;
+
+// src/commands/ListPolicyGenerationsCommand.ts
+
+
+
+
+var _ListPolicyGenerationsCommand = class _ListPolicyGenerationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListPolicyGenerations", {}).n("AccessAnalyzerClient", "ListPolicyGenerationsCommand").f(void 0, void 0).ser(se_ListPolicyGenerationsCommand).de(de_ListPolicyGenerationsCommand).build() {
+};
+__name(_ListPolicyGenerationsCommand, "ListPolicyGenerationsCommand");
+var ListPolicyGenerationsCommand = _ListPolicyGenerationsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ListTagsForResource", {}).n("AccessAnalyzerClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartPolicyGenerationCommand.ts
+
+
+
+
+var _StartPolicyGenerationCommand = class _StartPolicyGenerationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "StartPolicyGeneration", {}).n("AccessAnalyzerClient", "StartPolicyGenerationCommand").f(void 0, void 0).ser(se_StartPolicyGenerationCommand).de(de_StartPolicyGenerationCommand).build() {
+};
+__name(_StartPolicyGenerationCommand, "StartPolicyGenerationCommand");
+var StartPolicyGenerationCommand = _StartPolicyGenerationCommand;
+
+// src/commands/StartResourceScanCommand.ts
+
+
+
+
+var _StartResourceScanCommand = class _StartResourceScanCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "StartResourceScan", {}).n("AccessAnalyzerClient", "StartResourceScanCommand").f(void 0, void 0).ser(se_StartResourceScanCommand).de(de_StartResourceScanCommand).build() {
+};
+__name(_StartResourceScanCommand, "StartResourceScanCommand");
+var StartResourceScanCommand = _StartResourceScanCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "TagResource", {}).n("AccessAnalyzerClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "UntagResource", {}).n("AccessAnalyzerClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateArchiveRuleCommand.ts
+
+
+
+
+var _UpdateArchiveRuleCommand = class _UpdateArchiveRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "UpdateArchiveRule", {}).n("AccessAnalyzerClient", "UpdateArchiveRuleCommand").f(void 0, void 0).ser(se_UpdateArchiveRuleCommand).de(de_UpdateArchiveRuleCommand).build() {
+};
+__name(_UpdateArchiveRuleCommand, "UpdateArchiveRuleCommand");
+var UpdateArchiveRuleCommand = _UpdateArchiveRuleCommand;
+
+// src/commands/UpdateFindingsCommand.ts
+
+
+
+
+var _UpdateFindingsCommand = class _UpdateFindingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "UpdateFindings", {}).n("AccessAnalyzerClient", "UpdateFindingsCommand").f(void 0, void 0).ser(se_UpdateFindingsCommand).de(de_UpdateFindingsCommand).build() {
+};
+__name(_UpdateFindingsCommand, "UpdateFindingsCommand");
+var UpdateFindingsCommand = _UpdateFindingsCommand;
+
+// src/commands/ValidatePolicyCommand.ts
+
+
+
+
+var _ValidatePolicyCommand = class _ValidatePolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AccessAnalyzer", "ValidatePolicy", {}).n("AccessAnalyzerClient", "ValidatePolicyCommand").f(void 0, void 0).ser(se_ValidatePolicyCommand).de(de_ValidatePolicyCommand).build() {
+};
+__name(_ValidatePolicyCommand, "ValidatePolicyCommand");
+var ValidatePolicyCommand = _ValidatePolicyCommand;
+
+// src/AccessAnalyzer.ts
+var commands = {
+  ApplyArchiveRuleCommand,
+  CancelPolicyGenerationCommand,
+  CheckAccessNotGrantedCommand,
+  CheckNoNewAccessCommand,
+  CreateAccessPreviewCommand,
+  CreateAnalyzerCommand,
+  CreateArchiveRuleCommand,
+  DeleteAnalyzerCommand,
+  DeleteArchiveRuleCommand,
+  GetAccessPreviewCommand,
+  GetAnalyzedResourceCommand,
+  GetAnalyzerCommand,
+  GetArchiveRuleCommand,
+  GetFindingCommand,
+  GetFindingV2Command,
+  GetGeneratedPolicyCommand,
+  ListAccessPreviewFindingsCommand,
+  ListAccessPreviewsCommand,
+  ListAnalyzedResourcesCommand,
+  ListAnalyzersCommand,
+  ListArchiveRulesCommand,
+  ListFindingsCommand,
+  ListFindingsV2Command,
+  ListPolicyGenerationsCommand,
+  ListTagsForResourceCommand,
+  StartPolicyGenerationCommand,
+  StartResourceScanCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateArchiveRuleCommand,
+  UpdateFindingsCommand,
+  ValidatePolicyCommand
+};
+var _AccessAnalyzer = class _AccessAnalyzer extends AccessAnalyzerClient {
+};
+__name(_AccessAnalyzer, "AccessAnalyzer");
+var AccessAnalyzer = _AccessAnalyzer;
+(0, import_smithy_client.createAggregatedClient)(commands, AccessAnalyzer);
+
+// src/pagination/GetFindingV2Paginator.ts
+var import_core3 = require("@smithy/core");
+var paginateGetFindingV2 = (0, import_core3.createPaginator)(AccessAnalyzerClient, GetFindingV2Command, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListAccessPreviewFindingsPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateListAccessPreviewFindings = (0, import_core4.createPaginator)(AccessAnalyzerClient, ListAccessPreviewFindingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListAccessPreviewsPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateListAccessPreviews = (0, import_core5.createPaginator)(AccessAnalyzerClient, ListAccessPreviewsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListAnalyzedResourcesPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateListAnalyzedResources = (0, import_core6.createPaginator)(AccessAnalyzerClient, ListAnalyzedResourcesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListAnalyzersPaginator.ts
+var import_core7 = require("@smithy/core");
+var paginateListAnalyzers = (0, import_core7.createPaginator)(AccessAnalyzerClient, ListAnalyzersCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListArchiveRulesPaginator.ts
+var import_core8 = require("@smithy/core");
+var paginateListArchiveRules = (0, import_core8.createPaginator)(AccessAnalyzerClient, ListArchiveRulesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFindingsPaginator.ts
+var import_core9 = require("@smithy/core");
+var paginateListFindings = (0, import_core9.createPaginator)(AccessAnalyzerClient, ListFindingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFindingsV2Paginator.ts
+var import_core10 = require("@smithy/core");
+var paginateListFindingsV2 = (0, import_core10.createPaginator)(AccessAnalyzerClient, ListFindingsV2Command, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPolicyGenerationsPaginator.ts
+var import_core11 = require("@smithy/core");
+var paginateListPolicyGenerations = (0, import_core11.createPaginator)(AccessAnalyzerClient, ListPolicyGenerationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ValidatePolicyPaginator.ts
+var import_core12 = require("@smithy/core");
+var paginateValidatePolicy = (0, import_core12.createPaginator)(AccessAnalyzerClient, ValidatePolicyCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessAnalyzer,
+  AccessAnalyzerClient,
+  AccessAnalyzerServiceException,
+  AccessCheckPolicyType,
+  AccessDeniedException,
+  AccessPreviewStatus,
+  AccessPreviewStatusReasonCode,
+  AclGrantee,
+  AclPermission,
+  AnalyzerConfiguration,
+  ApplyArchiveRuleCommand,
+  CancelPolicyGenerationCommand,
+  CheckAccessNotGrantedCommand,
+  CheckAccessNotGrantedRequestFilterSensitiveLog,
+  CheckAccessNotGrantedResult,
+  CheckNoNewAccessCommand,
+  CheckNoNewAccessRequestFilterSensitiveLog,
+  CheckNoNewAccessResult,
+  Configuration,
+  ConflictException,
+  CreateAccessPreviewCommand,
+  CreateAnalyzerCommand,
+  CreateArchiveRuleCommand,
+  DeleteAnalyzerCommand,
+  DeleteArchiveRuleCommand,
+  FindingChangeType,
+  FindingDetails,
+  FindingType,
+  GetAccessPreviewCommand,
+  GetAnalyzedResourceCommand,
+  GetAnalyzerCommand,
+  GetArchiveRuleCommand,
+  GetFindingCommand,
+  GetFindingV2Command,
+  GetGeneratedPolicyCommand,
+  InternalServerException,
+  InvalidParameterException,
+  JobErrorCode,
+  JobStatus,
+  KmsGrantOperation,
+  ListAccessPreviewFindingsCommand,
+  ListAccessPreviewsCommand,
+  ListAnalyzedResourcesCommand,
+  ListAnalyzersCommand,
+  ListArchiveRulesCommand,
+  ListFindingsCommand,
+  ListFindingsV2Command,
+  ListPolicyGenerationsCommand,
+  ListTagsForResourceCommand,
+  Locale,
+  NetworkOriginConfiguration,
+  PathElement,
+  PolicyType,
+  RdsDbClusterSnapshotAttributeValue,
+  RdsDbSnapshotAttributeValue,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  StartPolicyGenerationCommand,
+  StartResourceScanCommand,
+  TagResourceCommand,
+  ThrottlingException,
+  UnprocessableEntityException,
+  UntagResourceCommand,
+  UpdateArchiveRuleCommand,
+  UpdateFindingsCommand,
+  ValidatePolicyCommand,
+  ValidatePolicyFindingType,
+  ValidatePolicyResourceType,
+  ValidationException,
+  ValidationExceptionReason,
+  __Client,
+  paginateGetFindingV2,
+  paginateListAccessPreviewFindings,
+  paginateListAccessPreviews,
+  paginateListAnalyzedResources,
+  paginateListAnalyzers,
+  paginateListArchiveRules,
+  paginateListFindings,
+  paginateListFindingsV2,
+  paginateListPolicyGenerations,
+  paginateValidatePolicy
+});