lambda-live-debugger/node_modules/@aws-sdk/client-iam/dist-cjs/index.js

Debug Lambda functions locally like it is running in the cloud

"use strict";
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, {
  AccessAdvisorUsageGranularityType: () => AccessAdvisorUsageGranularityType,
  AccessKeyFilterSensitiveLog: () => AccessKeyFilterSensitiveLog,
  AddClientIDToOpenIDConnectProviderCommand: () => AddClientIDToOpenIDConnectProviderCommand,
  AddRoleToInstanceProfileCommand: () => AddRoleToInstanceProfileCommand,
  AddUserToGroupCommand: () => AddUserToGroupCommand,
  AssignmentStatusType: () => AssignmentStatusType,
  AttachGroupPolicyCommand: () => AttachGroupPolicyCommand,
  AttachRolePolicyCommand: () => AttachRolePolicyCommand,
  AttachUserPolicyCommand: () => AttachUserPolicyCommand,
  ChangePasswordCommand: () => ChangePasswordCommand,
  ChangePasswordRequestFilterSensitiveLog: () => ChangePasswordRequestFilterSensitiveLog,
  ConcurrentModificationException: () => ConcurrentModificationException,
  ContextKeyTypeEnum: () => ContextKeyTypeEnum,
  CreateAccessKeyCommand: () => CreateAccessKeyCommand,
  CreateAccessKeyResponseFilterSensitiveLog: () => CreateAccessKeyResponseFilterSensitiveLog,
  CreateAccountAliasCommand: () => CreateAccountAliasCommand,
  CreateGroupCommand: () => CreateGroupCommand,
  CreateInstanceProfileCommand: () => CreateInstanceProfileCommand,
  CreateLoginProfileCommand: () => CreateLoginProfileCommand,
  CreateLoginProfileRequestFilterSensitiveLog: () => CreateLoginProfileRequestFilterSensitiveLog,
  CreateOpenIDConnectProviderCommand: () => CreateOpenIDConnectProviderCommand,
  CreatePolicyCommand: () => CreatePolicyCommand,
  CreatePolicyVersionCommand: () => CreatePolicyVersionCommand,
  CreateRoleCommand: () => CreateRoleCommand,
  CreateSAMLProviderCommand: () => CreateSAMLProviderCommand,
  CreateServiceLinkedRoleCommand: () => CreateServiceLinkedRoleCommand,
  CreateServiceSpecificCredentialCommand: () => CreateServiceSpecificCredentialCommand,
  CreateServiceSpecificCredentialResponseFilterSensitiveLog: () => CreateServiceSpecificCredentialResponseFilterSensitiveLog,
  CreateUserCommand: () => CreateUserCommand,
  CreateVirtualMFADeviceCommand: () => CreateVirtualMFADeviceCommand,
  CreateVirtualMFADeviceResponseFilterSensitiveLog: () => CreateVirtualMFADeviceResponseFilterSensitiveLog,
  CredentialReportExpiredException: () => CredentialReportExpiredException,
  CredentialReportNotPresentException: () => CredentialReportNotPresentException,
  CredentialReportNotReadyException: () => CredentialReportNotReadyException,
  DeactivateMFADeviceCommand: () => DeactivateMFADeviceCommand,
  DeleteAccessKeyCommand: () => DeleteAccessKeyCommand,
  DeleteAccountAliasCommand: () => DeleteAccountAliasCommand,
  DeleteAccountPasswordPolicyCommand: () => DeleteAccountPasswordPolicyCommand,
  DeleteConflictException: () => DeleteConflictException,
  DeleteGroupCommand: () => DeleteGroupCommand,
  DeleteGroupPolicyCommand: () => DeleteGroupPolicyCommand,
  DeleteInstanceProfileCommand: () => DeleteInstanceProfileCommand,
  DeleteLoginProfileCommand: () => DeleteLoginProfileCommand,
  DeleteOpenIDConnectProviderCommand: () => DeleteOpenIDConnectProviderCommand,
  DeletePolicyCommand: () => DeletePolicyCommand,
  DeletePolicyVersionCommand: () => DeletePolicyVersionCommand,
  DeleteRoleCommand: () => DeleteRoleCommand,
  DeleteRolePermissionsBoundaryCommand: () => DeleteRolePermissionsBoundaryCommand,
  DeleteRolePolicyCommand: () => DeleteRolePolicyCommand,
  DeleteSAMLProviderCommand: () => DeleteSAMLProviderCommand,
  DeleteSSHPublicKeyCommand: () => DeleteSSHPublicKeyCommand,
  DeleteServerCertificateCommand: () => DeleteServerCertificateCommand,
  DeleteServiceLinkedRoleCommand: () => DeleteServiceLinkedRoleCommand,
  DeleteServiceSpecificCredentialCommand: () => DeleteServiceSpecificCredentialCommand,
  DeleteSigningCertificateCommand: () => DeleteSigningCertificateCommand,
  DeleteUserCommand: () => DeleteUserCommand,
  DeleteUserPermissionsBoundaryCommand: () => DeleteUserPermissionsBoundaryCommand,
  DeleteUserPolicyCommand: () => DeleteUserPolicyCommand,
  DeleteVirtualMFADeviceCommand: () => DeleteVirtualMFADeviceCommand,
  DeletionTaskStatusType: () => DeletionTaskStatusType,
  DetachGroupPolicyCommand: () => DetachGroupPolicyCommand,
  DetachRolePolicyCommand: () => DetachRolePolicyCommand,
  DetachUserPolicyCommand: () => DetachUserPolicyCommand,
  DuplicateCertificateException: () => DuplicateCertificateException,
  DuplicateSSHPublicKeyException: () => DuplicateSSHPublicKeyException,
  EnableMFADeviceCommand: () => EnableMFADeviceCommand,
  EncodingType: () => EncodingType,
  EntityAlreadyExistsException: () => EntityAlreadyExistsException,
  EntityTemporarilyUnmodifiableException: () => EntityTemporarilyUnmodifiableException,
  EntityType: () => EntityType,
  GenerateCredentialReportCommand: () => GenerateCredentialReportCommand,
  GenerateOrganizationsAccessReportCommand: () => GenerateOrganizationsAccessReportCommand,
  GenerateServiceLastAccessedDetailsCommand: () => GenerateServiceLastAccessedDetailsCommand,
  GetAccessKeyLastUsedCommand: () => GetAccessKeyLastUsedCommand,
  GetAccountAuthorizationDetailsCommand: () => GetAccountAuthorizationDetailsCommand,
  GetAccountPasswordPolicyCommand: () => GetAccountPasswordPolicyCommand,
  GetAccountSummaryCommand: () => GetAccountSummaryCommand,
  GetContextKeysForCustomPolicyCommand: () => GetContextKeysForCustomPolicyCommand,
  GetContextKeysForPrincipalPolicyCommand: () => GetContextKeysForPrincipalPolicyCommand,
  GetCredentialReportCommand: () => GetCredentialReportCommand,
  GetGroupCommand: () => GetGroupCommand,
  GetGroupPolicyCommand: () => GetGroupPolicyCommand,
  GetInstanceProfileCommand: () => GetInstanceProfileCommand,
  GetLoginProfileCommand: () => GetLoginProfileCommand,
  GetMFADeviceCommand: () => GetMFADeviceCommand,
  GetOpenIDConnectProviderCommand: () => GetOpenIDConnectProviderCommand,
  GetOrganizationsAccessReportCommand: () => GetOrganizationsAccessReportCommand,
  GetPolicyCommand: () => GetPolicyCommand,
  GetPolicyVersionCommand: () => GetPolicyVersionCommand,
  GetRoleCommand: () => GetRoleCommand,
  GetRolePolicyCommand: () => GetRolePolicyCommand,
  GetSAMLProviderCommand: () => GetSAMLProviderCommand,
  GetSSHPublicKeyCommand: () => GetSSHPublicKeyCommand,
  GetServerCertificateCommand: () => GetServerCertificateCommand,
  GetServiceLastAccessedDetailsCommand: () => GetServiceLastAccessedDetailsCommand,
  GetServiceLastAccessedDetailsWithEntitiesCommand: () => GetServiceLastAccessedDetailsWithEntitiesCommand,
  GetServiceLinkedRoleDeletionStatusCommand: () => GetServiceLinkedRoleDeletionStatusCommand,
  GetUserCommand: () => GetUserCommand,
  GetUserPolicyCommand: () => GetUserPolicyCommand,
  GlobalEndpointTokenVersion: () => GlobalEndpointTokenVersion,
  IAM: () => IAM,
  IAMClient: () => IAMClient,
  IAMServiceException: () => IAMServiceException,
  InvalidAuthenticationCodeException: () => InvalidAuthenticationCodeException,
  InvalidCertificateException: () => InvalidCertificateException,
  InvalidInputException: () => InvalidInputException,
  InvalidPublicKeyException: () => InvalidPublicKeyException,
  InvalidUserTypeException: () => InvalidUserTypeException,
  JobStatusType: () => JobStatusType,
  KeyPairMismatchException: () => KeyPairMismatchException,
  LimitExceededException: () => LimitExceededException,
  ListAccessKeysCommand: () => ListAccessKeysCommand,
  ListAccountAliasesCommand: () => ListAccountAliasesCommand,
  ListAttachedGroupPoliciesCommand: () => ListAttachedGroupPoliciesCommand,
  ListAttachedRolePoliciesCommand: () => ListAttachedRolePoliciesCommand,
  ListAttachedUserPoliciesCommand: () => ListAttachedUserPoliciesCommand,
  ListEntitiesForPolicyCommand: () => ListEntitiesForPolicyCommand,
  ListGroupPoliciesCommand: () => ListGroupPoliciesCommand,
  ListGroupsCommand: () => ListGroupsCommand,
  ListGroupsForUserCommand: () => ListGroupsForUserCommand,
  ListInstanceProfileTagsCommand: () => ListInstanceProfileTagsCommand,
  ListInstanceProfilesCommand: () => ListInstanceProfilesCommand,
  ListInstanceProfilesForRoleCommand: () => ListInstanceProfilesForRoleCommand,
  ListMFADeviceTagsCommand: () => ListMFADeviceTagsCommand,
  ListMFADevicesCommand: () => ListMFADevicesCommand,
  ListOpenIDConnectProviderTagsCommand: () => ListOpenIDConnectProviderTagsCommand,
  ListOpenIDConnectProvidersCommand: () => ListOpenIDConnectProvidersCommand,
  ListPoliciesCommand: () => ListPoliciesCommand,
  ListPoliciesGrantingServiceAccessCommand: () => ListPoliciesGrantingServiceAccessCommand,
  ListPolicyTagsCommand: () => ListPolicyTagsCommand,
  ListPolicyVersionsCommand: () => ListPolicyVersionsCommand,
  ListRolePoliciesCommand: () => ListRolePoliciesCommand,
  ListRoleTagsCommand: () => ListRoleTagsCommand,
  ListRolesCommand: () => ListRolesCommand,
  ListSAMLProviderTagsCommand: () => ListSAMLProviderTagsCommand,
  ListSAMLProvidersCommand: () => ListSAMLProvidersCommand,
  ListSSHPublicKeysCommand: () => ListSSHPublicKeysCommand,
  ListServerCertificateTagsCommand: () => ListServerCertificateTagsCommand,
  ListServerCertificatesCommand: () => ListServerCertificatesCommand,
  ListServiceSpecificCredentialsCommand: () => ListServiceSpecificCredentialsCommand,
  ListSigningCertificatesCommand: () => ListSigningCertificatesCommand,
  ListUserPoliciesCommand: () => ListUserPoliciesCommand,
  ListUserTagsCommand: () => ListUserTagsCommand,
  ListUsersCommand: () => ListUsersCommand,
  ListVirtualMFADevicesCommand: () => ListVirtualMFADevicesCommand,
  ListVirtualMFADevicesResponseFilterSensitiveLog: () => ListVirtualMFADevicesResponseFilterSensitiveLog,
  MalformedCertificateException: () => MalformedCertificateException,
  MalformedPolicyDocumentException: () => MalformedPolicyDocumentException,
  NoSuchEntityException: () => NoSuchEntityException,
  OpenIdIdpCommunicationErrorException: () => OpenIdIdpCommunicationErrorException,
  PasswordPolicyViolationException: () => PasswordPolicyViolationException,
  PermissionsBoundaryAttachmentType: () => PermissionsBoundaryAttachmentType,
  PolicyEvaluationDecisionType: () => PolicyEvaluationDecisionType,
  PolicyEvaluationException: () => PolicyEvaluationException,
  PolicyNotAttachableException: () => PolicyNotAttachableException,
  PolicyOwnerEntityType: () => PolicyOwnerEntityType,
  PolicyScopeType: () => PolicyScopeType,
  PolicySourceType: () => PolicySourceType,
  PolicyType: () => PolicyType,
  PolicyUsageType: () => PolicyUsageType,
  PutGroupPolicyCommand: () => PutGroupPolicyCommand,
  PutRolePermissionsBoundaryCommand: () => PutRolePermissionsBoundaryCommand,
  PutRolePolicyCommand: () => PutRolePolicyCommand,
  PutUserPermissionsBoundaryCommand: () => PutUserPermissionsBoundaryCommand,
  PutUserPolicyCommand: () => PutUserPolicyCommand,
  RemoveClientIDFromOpenIDConnectProviderCommand: () => RemoveClientIDFromOpenIDConnectProviderCommand,
  RemoveRoleFromInstanceProfileCommand: () => RemoveRoleFromInstanceProfileCommand,
  RemoveUserFromGroupCommand: () => RemoveUserFromGroupCommand,
  ReportFormatType: () => ReportFormatType,
  ReportGenerationLimitExceededException: () => ReportGenerationLimitExceededException,
  ReportStateType: () => ReportStateType,
  ResetServiceSpecificCredentialCommand: () => ResetServiceSpecificCredentialCommand,
  ResetServiceSpecificCredentialResponseFilterSensitiveLog: () => ResetServiceSpecificCredentialResponseFilterSensitiveLog,
  ResyncMFADeviceCommand: () => ResyncMFADeviceCommand,
  ServiceFailureException: () => ServiceFailureException,
  ServiceNotSupportedException: () => ServiceNotSupportedException,
  ServiceSpecificCredentialFilterSensitiveLog: () => ServiceSpecificCredentialFilterSensitiveLog,
  SetDefaultPolicyVersionCommand: () => SetDefaultPolicyVersionCommand,
  SetSecurityTokenServicePreferencesCommand: () => SetSecurityTokenServicePreferencesCommand,
  SimulateCustomPolicyCommand: () => SimulateCustomPolicyCommand,
  SimulatePrincipalPolicyCommand: () => SimulatePrincipalPolicyCommand,
  SortKeyType: () => SortKeyType,
  StatusType: () => StatusType,
  SummaryKeyType: () => SummaryKeyType,
  TagInstanceProfileCommand: () => TagInstanceProfileCommand,
  TagMFADeviceCommand: () => TagMFADeviceCommand,
  TagOpenIDConnectProviderCommand: () => TagOpenIDConnectProviderCommand,
  TagPolicyCommand: () => TagPolicyCommand,
  TagRoleCommand: () => TagRoleCommand,
  TagSAMLProviderCommand: () => TagSAMLProviderCommand,
  TagServerCertificateCommand: () => TagServerCertificateCommand,
  TagUserCommand: () => TagUserCommand,
  UnmodifiableEntityException: () => UnmodifiableEntityException,
  UnrecognizedPublicKeyEncodingException: () => UnrecognizedPublicKeyEncodingException,
  UntagInstanceProfileCommand: () => UntagInstanceProfileCommand,
  UntagMFADeviceCommand: () => UntagMFADeviceCommand,
  UntagOpenIDConnectProviderCommand: () => UntagOpenIDConnectProviderCommand,
  UntagPolicyCommand: () => UntagPolicyCommand,
  UntagRoleCommand: () => UntagRoleCommand,
  UntagSAMLProviderCommand: () => UntagSAMLProviderCommand,
  UntagServerCertificateCommand: () => UntagServerCertificateCommand,
  UntagUserCommand: () => UntagUserCommand,
  UpdateAccessKeyCommand: () => UpdateAccessKeyCommand,
  UpdateAccountPasswordPolicyCommand: () => UpdateAccountPasswordPolicyCommand,
  UpdateAssumeRolePolicyCommand: () => UpdateAssumeRolePolicyCommand,
  UpdateGroupCommand: () => UpdateGroupCommand,
  UpdateLoginProfileCommand: () => UpdateLoginProfileCommand,
  UpdateLoginProfileRequestFilterSensitiveLog: () => UpdateLoginProfileRequestFilterSensitiveLog,
  UpdateOpenIDConnectProviderThumbprintCommand: () => UpdateOpenIDConnectProviderThumbprintCommand,
  UpdateRoleCommand: () => UpdateRoleCommand,
  UpdateRoleDescriptionCommand: () => UpdateRoleDescriptionCommand,
  UpdateSAMLProviderCommand: () => UpdateSAMLProviderCommand,
  UpdateSSHPublicKeyCommand: () => UpdateSSHPublicKeyCommand,
  UpdateServerCertificateCommand: () => UpdateServerCertificateCommand,
  UpdateServiceSpecificCredentialCommand: () => UpdateServiceSpecificCredentialCommand,
  UpdateSigningCertificateCommand: () => UpdateSigningCertificateCommand,
  UpdateUserCommand: () => UpdateUserCommand,
  UploadSSHPublicKeyCommand: () => UploadSSHPublicKeyCommand,
  UploadServerCertificateCommand: () => UploadServerCertificateCommand,
  UploadServerCertificateRequestFilterSensitiveLog: () => UploadServerCertificateRequestFilterSensitiveLog,
  UploadSigningCertificateCommand: () => UploadSigningCertificateCommand,
  VirtualMFADeviceFilterSensitiveLog: () => VirtualMFADeviceFilterSensitiveLog,
  __Client: () => import_smithy_client.Client,
  paginateGetAccountAuthorizationDetails: () => paginateGetAccountAuthorizationDetails,
  paginateGetGroup: () => paginateGetGroup,
  paginateListAccessKeys: () => paginateListAccessKeys,
  paginateListAccountAliases: () => paginateListAccountAliases,
  paginateListAttachedGroupPolicies: () => paginateListAttachedGroupPolicies,
  paginateListAttachedRolePolicies: () => paginateListAttachedRolePolicies,
  paginateListAttachedUserPolicies: () => paginateListAttachedUserPolicies,
  paginateListEntitiesForPolicy: () => paginateListEntitiesForPolicy,
  paginateListGroupPolicies: () => paginateListGroupPolicies,
  paginateListGroups: () => paginateListGroups,
  paginateListGroupsForUser: () => paginateListGroupsForUser,
  paginateListInstanceProfileTags: () => paginateListInstanceProfileTags,
  paginateListInstanceProfiles: () => paginateListInstanceProfiles,
  paginateListInstanceProfilesForRole: () => paginateListInstanceProfilesForRole,
  paginateListMFADeviceTags: () => paginateListMFADeviceTags,
  paginateListMFADevices: () => paginateListMFADevices,
  paginateListOpenIDConnectProviderTags: () => paginateListOpenIDConnectProviderTags,
  paginateListPolicies: () => paginateListPolicies,
  paginateListPolicyTags: () => paginateListPolicyTags,
  paginateListPolicyVersions: () => paginateListPolicyVersions,
  paginateListRolePolicies: () => paginateListRolePolicies,
  paginateListRoleTags: () => paginateListRoleTags,
  paginateListRoles: () => paginateListRoles,
  paginateListSAMLProviderTags: () => paginateListSAMLProviderTags,
  paginateListSSHPublicKeys: () => paginateListSSHPublicKeys,
  paginateListServerCertificateTags: () => paginateListServerCertificateTags,
  paginateListServerCertificates: () => paginateListServerCertificates,
  paginateListSigningCertificates: () => paginateListSigningCertificates,
  paginateListUserPolicies: () => paginateListUserPolicies,
  paginateListUserTags: () => paginateListUserTags,
  paginateListUsers: () => paginateListUsers,
  paginateListVirtualMFADevices: () => paginateListVirtualMFADevices,
  paginateSimulateCustomPolicy: () => paginateSimulateCustomPolicy,
  paginateSimulatePrincipalPolicy: () => paginateSimulatePrincipalPolicy,
  waitForInstanceProfileExists: () => waitForInstanceProfileExists,
  waitForPolicyExists: () => waitForPolicyExists,
  waitForRoleExists: () => waitForRoleExists,
  waitForUserExists: () => waitForUserExists,
  waitUntilInstanceProfileExists: () => waitUntilInstanceProfileExists,
  waitUntilPolicyExists: () => waitUntilPolicyExists,
  waitUntilRoleExists: () => waitUntilRoleExists,
  waitUntilUserExists: () => waitUntilUserExists
});
module.exports = __toCommonJS(src_exports);

// src/IAMClient.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_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
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");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "iam"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/IAMClient.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");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
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)),
    ...asPartial(getHttpAuthExtensionConfiguration(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),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/IAMClient.ts
var _IAMClient = class _IAMClient 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_user_agent.resolveUserAgentConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_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_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
  }
  getDefaultHttpAuthSchemeParametersProvider() {
    return import_httpAuthSchemeProvider.defaultIAMHttpAuthSchemeParametersProvider;
  }
  getIdentityProviderConfigProvider() {
    return async (config) => new import_core.DefaultIdentityProviderConfig({
      "aws.auth#sigv4": config.credentials
    });
  }
};
__name(_IAMClient, "IAMClient");
var IAMClient = _IAMClient;

// src/IAM.ts


// src/commands/AddClientIDToOpenIDConnectProviderCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");

var import_types = require("@smithy/types");

// src/protocols/Aws_query.ts
var import_core2 = require("@aws-sdk/core");



// src/models/IAMServiceException.ts

var _IAMServiceException = class _IAMServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _IAMServiceException.prototype);
  }
};
__name(_IAMServiceException, "IAMServiceException");
var IAMServiceException = _IAMServiceException;

// src/models/models_0.ts

var AccessAdvisorUsageGranularityType = {
  ACTION_LEVEL: "ACTION_LEVEL",
  SERVICE_LEVEL: "SERVICE_LEVEL"
};
var StatusType = {
  Active: "Active",
  Inactive: "Inactive"
};
var _InvalidInputException = class _InvalidInputException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidInputException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidInputException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidInputException.prototype);
  }
};
__name(_InvalidInputException, "InvalidInputException");
var InvalidInputException = _InvalidInputException;
var _LimitExceededException = class _LimitExceededException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _NoSuchEntityException = class _NoSuchEntityException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NoSuchEntityException",
      $fault: "client",
      ...opts
    });
    this.name = "NoSuchEntityException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _NoSuchEntityException.prototype);
  }
};
__name(_NoSuchEntityException, "NoSuchEntityException");
var NoSuchEntityException = _NoSuchEntityException;
var _ServiceFailureException = class _ServiceFailureException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceFailureException",
      $fault: "server",
      ...opts
    });
    this.name = "ServiceFailureException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _ServiceFailureException.prototype);
  }
};
__name(_ServiceFailureException, "ServiceFailureException");
var ServiceFailureException = _ServiceFailureException;
var _EntityAlreadyExistsException = class _EntityAlreadyExistsException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EntityAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "EntityAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _EntityAlreadyExistsException.prototype);
  }
};
__name(_EntityAlreadyExistsException, "EntityAlreadyExistsException");
var EntityAlreadyExistsException = _EntityAlreadyExistsException;
var _UnmodifiableEntityException = class _UnmodifiableEntityException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnmodifiableEntityException",
      $fault: "client",
      ...opts
    });
    this.name = "UnmodifiableEntityException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnmodifiableEntityException.prototype);
  }
};
__name(_UnmodifiableEntityException, "UnmodifiableEntityException");
var UnmodifiableEntityException = _UnmodifiableEntityException;
var AssignmentStatusType = {
  Any: "Any",
  Assigned: "Assigned",
  Unassigned: "Unassigned"
};
var PermissionsBoundaryAttachmentType = {
  Policy: "PermissionsBoundaryPolicy"
};
var _PolicyNotAttachableException = class _PolicyNotAttachableException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PolicyNotAttachableException",
      $fault: "client",
      ...opts
    });
    this.name = "PolicyNotAttachableException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PolicyNotAttachableException.prototype);
  }
};
__name(_PolicyNotAttachableException, "PolicyNotAttachableException");
var PolicyNotAttachableException = _PolicyNotAttachableException;
var _EntityTemporarilyUnmodifiableException = class _EntityTemporarilyUnmodifiableException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EntityTemporarilyUnmodifiableException",
      $fault: "client",
      ...opts
    });
    this.name = "EntityTemporarilyUnmodifiableException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _EntityTemporarilyUnmodifiableException.prototype);
  }
};
__name(_EntityTemporarilyUnmodifiableException, "EntityTemporarilyUnmodifiableException");
var EntityTemporarilyUnmodifiableException = _EntityTemporarilyUnmodifiableException;
var _InvalidUserTypeException = class _InvalidUserTypeException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidUserTypeException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidUserTypeException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidUserTypeException.prototype);
  }
};
__name(_InvalidUserTypeException, "InvalidUserTypeException");
var InvalidUserTypeException = _InvalidUserTypeException;
var _PasswordPolicyViolationException = class _PasswordPolicyViolationException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PasswordPolicyViolationException",
      $fault: "client",
      ...opts
    });
    this.name = "PasswordPolicyViolationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PasswordPolicyViolationException.prototype);
  }
};
__name(_PasswordPolicyViolationException, "PasswordPolicyViolationException");
var PasswordPolicyViolationException = _PasswordPolicyViolationException;
var _ConcurrentModificationException = class _ConcurrentModificationException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConcurrentModificationException",
      $fault: "client",
      ...opts
    });
    this.name = "ConcurrentModificationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
  }
};
__name(_ConcurrentModificationException, "ConcurrentModificationException");
var ConcurrentModificationException = _ConcurrentModificationException;
var _OpenIdIdpCommunicationErrorException = class _OpenIdIdpCommunicationErrorException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OpenIdIdpCommunicationErrorException",
      $fault: "client",
      ...opts
    });
    this.name = "OpenIdIdpCommunicationErrorException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OpenIdIdpCommunicationErrorException.prototype);
  }
};
__name(_OpenIdIdpCommunicationErrorException, "OpenIdIdpCommunicationErrorException");
var OpenIdIdpCommunicationErrorException = _OpenIdIdpCommunicationErrorException;
var _MalformedPolicyDocumentException = class _MalformedPolicyDocumentException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MalformedPolicyDocumentException",
      $fault: "client",
      ...opts
    });
    this.name = "MalformedPolicyDocumentException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MalformedPolicyDocumentException.prototype);
  }
};
__name(_MalformedPolicyDocumentException, "MalformedPolicyDocumentException");
var MalformedPolicyDocumentException = _MalformedPolicyDocumentException;
var _ServiceNotSupportedException = class _ServiceNotSupportedException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceNotSupportedException",
      $fault: "client",
      ...opts
    });
    this.name = "ServiceNotSupportedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ServiceNotSupportedException.prototype);
  }
};
__name(_ServiceNotSupportedException, "ServiceNotSupportedException");
var ServiceNotSupportedException = _ServiceNotSupportedException;
var _DeleteConflictException = class _DeleteConflictException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DeleteConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "DeleteConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DeleteConflictException.prototype);
  }
};
__name(_DeleteConflictException, "DeleteConflictException");
var DeleteConflictException = _DeleteConflictException;
var _InvalidAuthenticationCodeException = class _InvalidAuthenticationCodeException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAuthenticationCodeException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAuthenticationCodeException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAuthenticationCodeException.prototype);
  }
};
__name(_InvalidAuthenticationCodeException, "InvalidAuthenticationCodeException");
var InvalidAuthenticationCodeException = _InvalidAuthenticationCodeException;
var ReportStateType = {
  COMPLETE: "COMPLETE",
  INPROGRESS: "INPROGRESS",
  STARTED: "STARTED"
};
var _ReportGenerationLimitExceededException = class _ReportGenerationLimitExceededException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReportGenerationLimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ReportGenerationLimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReportGenerationLimitExceededException.prototype);
  }
};
__name(_ReportGenerationLimitExceededException, "ReportGenerationLimitExceededException");
var ReportGenerationLimitExceededException = _ReportGenerationLimitExceededException;
var EntityType = {
  AWSManagedPolicy: "AWSManagedPolicy",
  Group: "Group",
  LocalManagedPolicy: "LocalManagedPolicy",
  Role: "Role",
  User: "User"
};
var SummaryKeyType = {
  AccessKeysPerUserQuota: "AccessKeysPerUserQuota",
  AccountAccessKeysPresent: "AccountAccessKeysPresent",
  AccountMFAEnabled: "AccountMFAEnabled",
  AccountSigningCertificatesPresent: "AccountSigningCertificatesPresent",
  AttachedPoliciesPerGroupQuota: "AttachedPoliciesPerGroupQuota",
  AttachedPoliciesPerRoleQuota: "AttachedPoliciesPerRoleQuota",
  AttachedPoliciesPerUserQuota: "AttachedPoliciesPerUserQuota",
  GlobalEndpointTokenVersion: "GlobalEndpointTokenVersion",
  GroupPolicySizeQuota: "GroupPolicySizeQuota",
  Groups: "Groups",
  GroupsPerUserQuota: "GroupsPerUserQuota",
  GroupsQuota: "GroupsQuota",
  MFADevices: "MFADevices",
  MFADevicesInUse: "MFADevicesInUse",
  Policies: "Policies",
  PoliciesQuota: "PoliciesQuota",
  PolicySizeQuota: "PolicySizeQuota",
  PolicyVersionsInUse: "PolicyVersionsInUse",
  PolicyVersionsInUseQuota: "PolicyVersionsInUseQuota",
  ServerCertificates: "ServerCertificates",
  ServerCertificatesQuota: "ServerCertificatesQuota",
  SigningCertificatesPerUserQuota: "SigningCertificatesPerUserQuota",
  UserPolicySizeQuota: "UserPolicySizeQuota",
  Users: "Users",
  UsersQuota: "UsersQuota",
  VersionsPerPolicyQuota: "VersionsPerPolicyQuota"
};
var _CredentialReportExpiredException = class _CredentialReportExpiredException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CredentialReportExpiredException",
      $fault: "client",
      ...opts
    });
    this.name = "CredentialReportExpiredException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CredentialReportExpiredException.prototype);
  }
};
__name(_CredentialReportExpiredException, "CredentialReportExpiredException");
var CredentialReportExpiredException = _CredentialReportExpiredException;
var _CredentialReportNotPresentException = class _CredentialReportNotPresentException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CredentialReportNotPresentException",
      $fault: "client",
      ...opts
    });
    this.name = "CredentialReportNotPresentException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CredentialReportNotPresentException.prototype);
  }
};
__name(_CredentialReportNotPresentException, "CredentialReportNotPresentException");
var CredentialReportNotPresentException = _CredentialReportNotPresentException;
var _CredentialReportNotReadyException = class _CredentialReportNotReadyException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CredentialReportNotReadyException",
      $fault: "client",
      ...opts
    });
    this.name = "CredentialReportNotReadyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CredentialReportNotReadyException.prototype);
  }
};
__name(_CredentialReportNotReadyException, "CredentialReportNotReadyException");
var CredentialReportNotReadyException = _CredentialReportNotReadyException;
var ReportFormatType = {
  text_csv: "text/csv"
};
var SortKeyType = {
  LAST_AUTHENTICATED_TIME_ASCENDING: "LAST_AUTHENTICATED_TIME_ASCENDING",
  LAST_AUTHENTICATED_TIME_DESCENDING: "LAST_AUTHENTICATED_TIME_DESCENDING",
  SERVICE_NAMESPACE_ASCENDING: "SERVICE_NAMESPACE_ASCENDING",
  SERVICE_NAMESPACE_DESCENDING: "SERVICE_NAMESPACE_DESCENDING"
};
var JobStatusType = {
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS"
};
var PolicyOwnerEntityType = {
  GROUP: "GROUP",
  ROLE: "ROLE",
  USER: "USER"
};
var DeletionTaskStatusType = {
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  NOT_STARTED: "NOT_STARTED",
  SUCCEEDED: "SUCCEEDED"
};
var EncodingType = {
  PEM: "PEM",
  SSH: "SSH"
};
var _UnrecognizedPublicKeyEncodingException = class _UnrecognizedPublicKeyEncodingException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnrecognizedPublicKeyEncodingException",
      $fault: "client",
      ...opts
    });
    this.name = "UnrecognizedPublicKeyEncodingException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnrecognizedPublicKeyEncodingException.prototype);
  }
};
__name(_UnrecognizedPublicKeyEncodingException, "UnrecognizedPublicKeyEncodingException");
var UnrecognizedPublicKeyEncodingException = _UnrecognizedPublicKeyEncodingException;
var PolicyUsageType = {
  PermissionsBoundary: "PermissionsBoundary",
  PermissionsPolicy: "PermissionsPolicy"
};
var PolicyScopeType = {
  AWS: "AWS",
  All: "All",
  Local: "Local"
};
var PolicyType = {
  INLINE: "INLINE",
  MANAGED: "MANAGED"
};
var GlobalEndpointTokenVersion = {
  v1Token: "v1Token",
  v2Token: "v2Token"
};
var _PolicyEvaluationException = class _PolicyEvaluationException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PolicyEvaluationException",
      $fault: "server",
      ...opts
    });
    this.name = "PolicyEvaluationException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _PolicyEvaluationException.prototype);
  }
};
__name(_PolicyEvaluationException, "PolicyEvaluationException");
var PolicyEvaluationException = _PolicyEvaluationException;
var ContextKeyTypeEnum = {
  BINARY: "binary",
  BINARY_LIST: "binaryList",
  BOOLEAN: "boolean",
  BOOLEAN_LIST: "booleanList",
  DATE: "date",
  DATE_LIST: "dateList",
  IP: "ip",
  IP_LIST: "ipList",
  NUMERIC: "numeric",
  NUMERIC_LIST: "numericList",
  STRING: "string",
  STRING_LIST: "stringList"
};
var PolicyEvaluationDecisionType = {
  ALLOWED: "allowed",
  EXPLICIT_DENY: "explicitDeny",
  IMPLICIT_DENY: "implicitDeny"
};
var PolicySourceType = {
  AWS_MANAGED: "aws-managed",
  GROUP: "group",
  NONE: "none",
  RESOURCE: "resource",
  ROLE: "role",
  USER: "user",
  USER_MANAGED: "user-managed"
};
var AccessKeyFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SecretAccessKey && { SecretAccessKey: import_smithy_client.SENSITIVE_STRING }
}), "AccessKeyFilterSensitiveLog");
var ChangePasswordRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.OldPassword && { OldPassword: import_smithy_client.SENSITIVE_STRING },
  ...obj.NewPassword && { NewPassword: import_smithy_client.SENSITIVE_STRING }
}), "ChangePasswordRequestFilterSensitiveLog");
var CreateAccessKeyResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AccessKey && { AccessKey: AccessKeyFilterSensitiveLog(obj.AccessKey) }
}), "CreateAccessKeyResponseFilterSensitiveLog");
var CreateLoginProfileRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
}), "CreateLoginProfileRequestFilterSensitiveLog");
var ServiceSpecificCredentialFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ServicePassword && { ServicePassword: import_smithy_client.SENSITIVE_STRING }
}), "ServiceSpecificCredentialFilterSensitiveLog");
var CreateServiceSpecificCredentialResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ServiceSpecificCredential && {
    ServiceSpecificCredential: ServiceSpecificCredentialFilterSensitiveLog(obj.ServiceSpecificCredential)
  }
}), "CreateServiceSpecificCredentialResponseFilterSensitiveLog");
var VirtualMFADeviceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Base32StringSeed && { Base32StringSeed: import_smithy_client.SENSITIVE_STRING },
  ...obj.QRCodePNG && { QRCodePNG: import_smithy_client.SENSITIVE_STRING }
}), "VirtualMFADeviceFilterSensitiveLog");
var CreateVirtualMFADeviceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.VirtualMFADevice && { VirtualMFADevice: VirtualMFADeviceFilterSensitiveLog(obj.VirtualMFADevice) }
}), "CreateVirtualMFADeviceResponseFilterSensitiveLog");
var ListVirtualMFADevicesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.VirtualMFADevices && {
    VirtualMFADevices: obj.VirtualMFADevices.map((item) => VirtualMFADeviceFilterSensitiveLog(item))
  }
}), "ListVirtualMFADevicesResponseFilterSensitiveLog");
var ResetServiceSpecificCredentialResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ServiceSpecificCredential && {
    ServiceSpecificCredential: ServiceSpecificCredentialFilterSensitiveLog(obj.ServiceSpecificCredential)
  }
}), "ResetServiceSpecificCredentialResponseFilterSensitiveLog");

// src/models/models_1.ts

var _KeyPairMismatchException = class _KeyPairMismatchException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KeyPairMismatchException",
      $fault: "client",
      ...opts
    });
    this.name = "KeyPairMismatchException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KeyPairMismatchException.prototype);
  }
};
__name(_KeyPairMismatchException, "KeyPairMismatchException");
var KeyPairMismatchException = _KeyPairMismatchException;
var _MalformedCertificateException = class _MalformedCertificateException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MalformedCertificateException",
      $fault: "client",
      ...opts
    });
    this.name = "MalformedCertificateException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MalformedCertificateException.prototype);
  }
};
__name(_MalformedCertificateException, "MalformedCertificateException");
var MalformedCertificateException = _MalformedCertificateException;
var _DuplicateCertificateException = class _DuplicateCertificateException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DuplicateCertificateException",
      $fault: "client",
      ...opts
    });
    this.name = "DuplicateCertificateException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DuplicateCertificateException.prototype);
  }
};
__name(_DuplicateCertificateException, "DuplicateCertificateException");
var DuplicateCertificateException = _DuplicateCertificateException;
var _InvalidCertificateException = class _InvalidCertificateException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidCertificateException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidCertificateException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidCertificateException.prototype);
  }
};
__name(_InvalidCertificateException, "InvalidCertificateException");
var InvalidCertificateException = _InvalidCertificateException;
var _DuplicateSSHPublicKeyException = class _DuplicateSSHPublicKeyException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DuplicateSSHPublicKeyException",
      $fault: "client",
      ...opts
    });
    this.name = "DuplicateSSHPublicKeyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DuplicateSSHPublicKeyException.prototype);
  }
};
__name(_DuplicateSSHPublicKeyException, "DuplicateSSHPublicKeyException");
var DuplicateSSHPublicKeyException = _DuplicateSSHPublicKeyException;
var _InvalidPublicKeyException = class _InvalidPublicKeyException extends IAMServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidPublicKeyException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidPublicKeyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidPublicKeyException.prototype);
  }
};
__name(_InvalidPublicKeyException, "InvalidPublicKeyException");
var InvalidPublicKeyException = _InvalidPublicKeyException;
var UpdateLoginProfileRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
}), "UpdateLoginProfileRequestFilterSensitiveLog");
var UploadServerCertificateRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PrivateKey && { PrivateKey: import_smithy_client.SENSITIVE_STRING }
}), "UploadServerCertificateRequestFilterSensitiveLog");

// src/protocols/Aws_query.ts
var se_AddClientIDToOpenIDConnectProviderCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AddClientIDToOpenIDConnectProviderRequest(input, context),
    [_A]: _ACIDTOIDCP,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AddClientIDToOpenIDConnectProviderCommand");
var se_AddRoleToInstanceProfileCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AddRoleToInstanceProfileRequest(input, context),
    [_A]: _ARTIP,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AddRoleToInstanceProfileCommand");
var se_AddUserToGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AddUserToGroupRequest(input, context),
    [_A]: _AUTG,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AddUserToGroupCommand");
var se_AttachGroupPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AttachGroupPolicyRequest(input, context),
    [_A]: _AGP,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AttachGroupPolicyCommand");
var se_AttachRolePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AttachRolePolicyRequest(input, context),
    [_A]: _ARP,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AttachRolePolicyCommand");
var se_AttachUserPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_AttachUserPolicyRequest(input, context),
    [_A]: