import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
import { IAMServiceException as __BaseException } from "./IAMServiceException";
export declare enum AccessAdvisorUsageGranularityType {
    ACTION_LEVEL = "ACTION_LEVEL",
    SERVICE_LEVEL = "SERVICE_LEVEL"
}

export interface AccessDetail {
    
    ServiceName: string | undefined;
    
    ServiceNamespace: string | undefined;
    
    Region?: string;
    
    EntityPath?: string;
    
    LastAuthenticatedTime?: Date;
    
    TotalAuthenticatedEntities?: number;
}
export declare namespace AccessDetail {
    
    const filterSensitiveLog: (obj: AccessDetail) => any;
}
export declare type StatusType = "Active" | "Inactive";

export interface AccessKey {
    
    UserName: string | undefined;
    
    AccessKeyId: string | undefined;
    
    Status: StatusType | string | undefined;
    
    SecretAccessKey: string | undefined;
    
    CreateDate?: Date;
}
export declare namespace AccessKey {
    
    const filterSensitiveLog: (obj: AccessKey) => any;
}

export interface AccessKeyLastUsed {
    
    LastUsedDate: Date | undefined;
    
    ServiceName: string | undefined;
    
    Region: string | undefined;
}
export declare namespace AccessKeyLastUsed {
    
    const filterSensitiveLog: (obj: AccessKeyLastUsed) => any;
}

export interface AccessKeyMetadata {
    
    UserName?: string;
    
    AccessKeyId?: string;
    
    Status?: StatusType | string;
    
    CreateDate?: Date;
}
export declare namespace AccessKeyMetadata {
    
    const filterSensitiveLog: (obj: AccessKeyMetadata) => any;
}
export interface AddClientIDToOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
    
    ClientID: string | undefined;
}
export declare namespace AddClientIDToOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: AddClientIDToOpenIDConnectProviderRequest) => any;
}

export declare class InvalidInputException extends __BaseException {
    readonly name: "InvalidInputException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidInputException, __BaseException>);
}

export declare class LimitExceededException extends __BaseException {
    readonly name: "LimitExceededException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
}

export declare class NoSuchEntityException extends __BaseException {
    readonly name: "NoSuchEntityException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<NoSuchEntityException, __BaseException>);
}

export declare class ServiceFailureException extends __BaseException {
    readonly name: "ServiceFailureException";
    readonly $fault: "server";
    
    constructor(opts: __ExceptionOptionType<ServiceFailureException, __BaseException>);
}
export interface AddRoleToInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
    
    RoleName: string | undefined;
}
export declare namespace AddRoleToInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: AddRoleToInstanceProfileRequest) => any;
}

export declare class EntityAlreadyExistsException extends __BaseException {
    readonly name: "EntityAlreadyExistsException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<EntityAlreadyExistsException, __BaseException>);
}

export declare class UnmodifiableEntityException extends __BaseException {
    readonly name: "UnmodifiableEntityException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<UnmodifiableEntityException, __BaseException>);
}
export interface AddUserToGroupRequest {
    
    GroupName: string | undefined;
    
    UserName: string | undefined;
}
export declare namespace AddUserToGroupRequest {
    
    const filterSensitiveLog: (obj: AddUserToGroupRequest) => any;
}
export declare type AssignmentStatusType = "Any" | "Assigned" | "Unassigned";
export declare enum PermissionsBoundaryAttachmentType {
    Policy = "PermissionsBoundaryPolicy"
}

export interface AttachedPermissionsBoundary {
    
    PermissionsBoundaryType?: PermissionsBoundaryAttachmentType | string;
    
    PermissionsBoundaryArn?: string;
}
export declare namespace AttachedPermissionsBoundary {
    
    const filterSensitiveLog: (obj: AttachedPermissionsBoundary) => any;
}

export interface AttachedPolicy {
    
    PolicyName?: string;
    
    PolicyArn?: string;
}
export declare namespace AttachedPolicy {
    
    const filterSensitiveLog: (obj: AttachedPolicy) => any;
}
export interface AttachGroupPolicyRequest {
    
    GroupName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace AttachGroupPolicyRequest {
    
    const filterSensitiveLog: (obj: AttachGroupPolicyRequest) => any;
}

export declare class PolicyNotAttachableException extends __BaseException {
    readonly name: "PolicyNotAttachableException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PolicyNotAttachableException, __BaseException>);
}
export interface AttachRolePolicyRequest {
    
    RoleName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace AttachRolePolicyRequest {
    
    const filterSensitiveLog: (obj: AttachRolePolicyRequest) => any;
}
export interface AttachUserPolicyRequest {
    
    UserName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace AttachUserPolicyRequest {
    
    const filterSensitiveLog: (obj: AttachUserPolicyRequest) => any;
}
export interface ChangePasswordRequest {
    
    OldPassword: string | undefined;
    
    NewPassword: string | undefined;
}
export declare namespace ChangePasswordRequest {
    
    const filterSensitiveLog: (obj: ChangePasswordRequest) => any;
}

export declare class EntityTemporarilyUnmodifiableException extends __BaseException {
    readonly name: "EntityTemporarilyUnmodifiableException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<EntityTemporarilyUnmodifiableException, __BaseException>);
}

export declare class InvalidUserTypeException extends __BaseException {
    readonly name: "InvalidUserTypeException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidUserTypeException, __BaseException>);
}

export declare class PasswordPolicyViolationException extends __BaseException {
    readonly name: "PasswordPolicyViolationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PasswordPolicyViolationException, __BaseException>);
}
export interface CreateAccessKeyRequest {
    
    UserName?: string;
}
export declare namespace CreateAccessKeyRequest {
    
    const filterSensitiveLog: (obj: CreateAccessKeyRequest) => any;
}

export interface CreateAccessKeyResponse {
    
    AccessKey: AccessKey | undefined;
}
export declare namespace CreateAccessKeyResponse {
    
    const filterSensitiveLog: (obj: CreateAccessKeyResponse) => any;
}
export interface CreateAccountAliasRequest {
    
    AccountAlias: string | undefined;
}
export declare namespace CreateAccountAliasRequest {
    
    const filterSensitiveLog: (obj: CreateAccountAliasRequest) => any;
}
export interface CreateGroupRequest {
    
    Path?: string;
    
    GroupName: string | undefined;
}
export declare namespace CreateGroupRequest {
    
    const filterSensitiveLog: (obj: CreateGroupRequest) => any;
}

export interface Group {
    
    Path: string | undefined;
    
    GroupName: string | undefined;
    
    GroupId: string | undefined;
    
    Arn: string | undefined;
    
    CreateDate: Date | undefined;
}
export declare namespace Group {
    
    const filterSensitiveLog: (obj: Group) => any;
}

export interface CreateGroupResponse {
    
    Group: Group | undefined;
}
export declare namespace CreateGroupResponse {
    
    const filterSensitiveLog: (obj: CreateGroupResponse) => any;
}

export declare class ConcurrentModificationException extends __BaseException {
    readonly name: "ConcurrentModificationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
}

export interface Tag {
    
    Key: string | undefined;
    
    Value: string | undefined;
}
export declare namespace Tag {
    
    const filterSensitiveLog: (obj: Tag) => any;
}
export interface CreateInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
    
    Path?: string;
    
    Tags?: Tag[];
}
export declare namespace CreateInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: CreateInstanceProfileRequest) => any;
}

export interface RoleLastUsed {
    
    LastUsedDate?: Date;
    
    Region?: string;
}
export declare namespace RoleLastUsed {
    
    const filterSensitiveLog: (obj: RoleLastUsed) => any;
}

export interface Role {
    
    Path: string | undefined;
    
    RoleName: string | undefined;
    
    RoleId: string | undefined;
    
    Arn: string | undefined;
    
    CreateDate: Date | undefined;
    
    AssumeRolePolicyDocument?: string;
    
    Description?: string;
    
    MaxSessionDuration?: number;
    
    PermissionsBoundary?: AttachedPermissionsBoundary;
    
    Tags?: Tag[];
    
    RoleLastUsed?: RoleLastUsed;
}
export declare namespace Role {
    
    const filterSensitiveLog: (obj: Role) => any;
}

export interface InstanceProfile {
    
    Path: string | undefined;
    
    InstanceProfileName: string | undefined;
    
    InstanceProfileId: string | undefined;
    
    Arn: string | undefined;
    
    CreateDate: Date | undefined;
    
    Roles: Role[] | undefined;
    
    Tags?: Tag[];
}
export declare namespace InstanceProfile {
    
    const filterSensitiveLog: (obj: InstanceProfile) => any;
}

export interface CreateInstanceProfileResponse {
    
    InstanceProfile: InstanceProfile | undefined;
}
export declare namespace CreateInstanceProfileResponse {
    
    const filterSensitiveLog: (obj: CreateInstanceProfileResponse) => any;
}
export interface CreateLoginProfileRequest {
    
    UserName: string | undefined;
    
    Password: string | undefined;
    
    PasswordResetRequired?: boolean;
}
export declare namespace CreateLoginProfileRequest {
    
    const filterSensitiveLog: (obj: CreateLoginProfileRequest) => any;
}

export interface LoginProfile {
    
    UserName: string | undefined;
    
    CreateDate: Date | undefined;
    
    PasswordResetRequired?: boolean;
}
export declare namespace LoginProfile {
    
    const filterSensitiveLog: (obj: LoginProfile) => any;
}

export interface CreateLoginProfileResponse {
    
    LoginProfile: LoginProfile | undefined;
}
export declare namespace CreateLoginProfileResponse {
    
    const filterSensitiveLog: (obj: CreateLoginProfileResponse) => any;
}
export interface CreateOpenIDConnectProviderRequest {
    
    Url: string | undefined;
    
    ClientIDList?: string[];
    
    ThumbprintList: string[] | undefined;
    
    Tags?: Tag[];
}
export declare namespace CreateOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: CreateOpenIDConnectProviderRequest) => any;
}

export interface CreateOpenIDConnectProviderResponse {
    
    OpenIDConnectProviderArn?: string;
    
    Tags?: Tag[];
}
export declare namespace CreateOpenIDConnectProviderResponse {
    
    const filterSensitiveLog: (obj: CreateOpenIDConnectProviderResponse) => any;
}
export interface CreatePolicyRequest {
    
    PolicyName: string | undefined;
    
    Path?: string;
    
    PolicyDocument: string | undefined;
    
    Description?: string;
    
    Tags?: Tag[];
}
export declare namespace CreatePolicyRequest {
    
    const filterSensitiveLog: (obj: CreatePolicyRequest) => any;
}

export interface Policy {
    
    PolicyName?: string;
    
    PolicyId?: string;
    
    Arn?: string;
    
    Path?: string;
    
    DefaultVersionId?: string;
    
    AttachmentCount?: number;
    
    PermissionsBoundaryUsageCount?: number;
    
    IsAttachable?: boolean;
    
    Description?: string;
    
    CreateDate?: Date;
    
    UpdateDate?: Date;
    
    Tags?: Tag[];
}
export declare namespace Policy {
    
    const filterSensitiveLog: (obj: Policy) => any;
}

export interface CreatePolicyResponse {
    
    Policy?: Policy;
}
export declare namespace CreatePolicyResponse {
    
    const filterSensitiveLog: (obj: CreatePolicyResponse) => any;
}

export declare class MalformedPolicyDocumentException extends __BaseException {
    readonly name: "MalformedPolicyDocumentException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<MalformedPolicyDocumentException, __BaseException>);
}
export interface CreatePolicyVersionRequest {
    
    PolicyArn: string | undefined;
    
    PolicyDocument: string | undefined;
    
    SetAsDefault?: boolean;
}
export declare namespace CreatePolicyVersionRequest {
    
    const filterSensitiveLog: (obj: CreatePolicyVersionRequest) => any;
}

export interface PolicyVersion {
    
    Document?: string;
    
    VersionId?: string;
    
    IsDefaultVersion?: boolean;
    
    CreateDate?: Date;
}
export declare namespace PolicyVersion {
    
    const filterSensitiveLog: (obj: PolicyVersion) => any;
}

export interface CreatePolicyVersionResponse {
    
    PolicyVersion?: PolicyVersion;
}
export declare namespace CreatePolicyVersionResponse {
    
    const filterSensitiveLog: (obj: CreatePolicyVersionResponse) => any;
}
export interface CreateRoleRequest {
    
    Path?: string;
    
    RoleName: string | undefined;
    
    AssumeRolePolicyDocument: string | undefined;
    
    Description?: string;
    
    MaxSessionDuration?: number;
    
    PermissionsBoundary?: string;
    
    Tags?: Tag[];
}
export declare namespace CreateRoleRequest {
    
    const filterSensitiveLog: (obj: CreateRoleRequest) => any;
}

export interface CreateRoleResponse {
    
    Role: Role | undefined;
}
export declare namespace CreateRoleResponse {
    
    const filterSensitiveLog: (obj: CreateRoleResponse) => any;
}
export interface CreateSAMLProviderRequest {
    
    SAMLMetadataDocument: string | undefined;
    
    Name: string | undefined;
    
    Tags?: Tag[];
}
export declare namespace CreateSAMLProviderRequest {
    
    const filterSensitiveLog: (obj: CreateSAMLProviderRequest) => any;
}

export interface CreateSAMLProviderResponse {
    
    SAMLProviderArn?: string;
    
    Tags?: Tag[];
}
export declare namespace CreateSAMLProviderResponse {
    
    const filterSensitiveLog: (obj: CreateSAMLProviderResponse) => any;
}
export interface CreateServiceLinkedRoleRequest {
    
    AWSServiceName: string | undefined;
    
    Description?: string;
    
    CustomSuffix?: string;
}
export declare namespace CreateServiceLinkedRoleRequest {
    
    const filterSensitiveLog: (obj: CreateServiceLinkedRoleRequest) => any;
}
export interface CreateServiceLinkedRoleResponse {
    
    Role?: Role;
}
export declare namespace CreateServiceLinkedRoleResponse {
    
    const filterSensitiveLog: (obj: CreateServiceLinkedRoleResponse) => any;
}
export interface CreateServiceSpecificCredentialRequest {
    
    UserName: string | undefined;
    
    ServiceName: string | undefined;
}
export declare namespace CreateServiceSpecificCredentialRequest {
    
    const filterSensitiveLog: (obj: CreateServiceSpecificCredentialRequest) => any;
}

export interface ServiceSpecificCredential {
    
    CreateDate: Date | undefined;
    
    ServiceName: string | undefined;
    
    ServiceUserName: string | undefined;
    
    ServicePassword: string | undefined;
    
    ServiceSpecificCredentialId: string | undefined;
    
    UserName: string | undefined;
    
    Status: StatusType | string | undefined;
}
export declare namespace ServiceSpecificCredential {
    
    const filterSensitiveLog: (obj: ServiceSpecificCredential) => any;
}
export interface CreateServiceSpecificCredentialResponse {
    
    ServiceSpecificCredential?: ServiceSpecificCredential;
}
export declare namespace CreateServiceSpecificCredentialResponse {
    
    const filterSensitiveLog: (obj: CreateServiceSpecificCredentialResponse) => any;
}

export declare class ServiceNotSupportedException extends __BaseException {
    readonly name: "ServiceNotSupportedException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ServiceNotSupportedException, __BaseException>);
}
export interface CreateUserRequest {
    
    Path?: string;
    
    UserName: string | undefined;
    
    PermissionsBoundary?: string;
    
    Tags?: Tag[];
}
export declare namespace CreateUserRequest {
    
    const filterSensitiveLog: (obj: CreateUserRequest) => any;
}

export interface User {
    
    Path: string | undefined;
    
    UserName: string | undefined;
    
    UserId: string | undefined;
    
    Arn: string | undefined;
    
    CreateDate: Date | undefined;
    
    PasswordLastUsed?: Date;
    
    PermissionsBoundary?: AttachedPermissionsBoundary;
    
    Tags?: Tag[];
}
export declare namespace User {
    
    const filterSensitiveLog: (obj: User) => any;
}

export interface CreateUserResponse {
    
    User?: User;
}
export declare namespace CreateUserResponse {
    
    const filterSensitiveLog: (obj: CreateUserResponse) => any;
}
export interface CreateVirtualMFADeviceRequest {
    
    Path?: string;
    
    VirtualMFADeviceName: string | undefined;
    
    Tags?: Tag[];
}
export declare namespace CreateVirtualMFADeviceRequest {
    
    const filterSensitiveLog: (obj: CreateVirtualMFADeviceRequest) => any;
}

export interface VirtualMFADevice {
    
    SerialNumber: string | undefined;
    
    Base32StringSeed?: Uint8Array;
    
    QRCodePNG?: Uint8Array;
    
    User?: User;
    
    EnableDate?: Date;
    
    Tags?: Tag[];
}
export declare namespace VirtualMFADevice {
    
    const filterSensitiveLog: (obj: VirtualMFADevice) => any;
}

export interface CreateVirtualMFADeviceResponse {
    
    VirtualMFADevice: VirtualMFADevice | undefined;
}
export declare namespace CreateVirtualMFADeviceResponse {
    
    const filterSensitiveLog: (obj: CreateVirtualMFADeviceResponse) => any;
}
export interface DeactivateMFADeviceRequest {
    
    UserName: string | undefined;
    
    SerialNumber: string | undefined;
}
export declare namespace DeactivateMFADeviceRequest {
    
    const filterSensitiveLog: (obj: DeactivateMFADeviceRequest) => any;
}
export interface DeleteAccessKeyRequest {
    
    UserName?: string;
    
    AccessKeyId: string | undefined;
}
export declare namespace DeleteAccessKeyRequest {
    
    const filterSensitiveLog: (obj: DeleteAccessKeyRequest) => any;
}
export interface DeleteAccountAliasRequest {
    
    AccountAlias: string | undefined;
}
export declare namespace DeleteAccountAliasRequest {
    
    const filterSensitiveLog: (obj: DeleteAccountAliasRequest) => any;
}

export declare class DeleteConflictException extends __BaseException {
    readonly name: "DeleteConflictException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<DeleteConflictException, __BaseException>);
}
export interface DeleteGroupRequest {
    
    GroupName: string | undefined;
}
export declare namespace DeleteGroupRequest {
    
    const filterSensitiveLog: (obj: DeleteGroupRequest) => any;
}
export interface DeleteGroupPolicyRequest {
    
    GroupName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace DeleteGroupPolicyRequest {
    
    const filterSensitiveLog: (obj: DeleteGroupPolicyRequest) => any;
}
export interface DeleteInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
}
export declare namespace DeleteInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: DeleteInstanceProfileRequest) => any;
}
export interface DeleteLoginProfileRequest {
    
    UserName: string | undefined;
}
export declare namespace DeleteLoginProfileRequest {
    
    const filterSensitiveLog: (obj: DeleteLoginProfileRequest) => any;
}
export interface DeleteOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
}
export declare namespace DeleteOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: DeleteOpenIDConnectProviderRequest) => any;
}
export interface DeletePolicyRequest {
    
    PolicyArn: string | undefined;
}
export declare namespace DeletePolicyRequest {
    
    const filterSensitiveLog: (obj: DeletePolicyRequest) => any;
}
export interface DeletePolicyVersionRequest {
    
    PolicyArn: string | undefined;
    
    VersionId: string | undefined;
}
export declare namespace DeletePolicyVersionRequest {
    
    const filterSensitiveLog: (obj: DeletePolicyVersionRequest) => any;
}
export interface DeleteRoleRequest {
    
    RoleName: string | undefined;
}
export declare namespace DeleteRoleRequest {
    
    const filterSensitiveLog: (obj: DeleteRoleRequest) => any;
}
export interface DeleteRolePermissionsBoundaryRequest {
    
    RoleName: string | undefined;
}
export declare namespace DeleteRolePermissionsBoundaryRequest {
    
    const filterSensitiveLog: (obj: DeleteRolePermissionsBoundaryRequest) => any;
}
export interface DeleteRolePolicyRequest {
    
    RoleName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace DeleteRolePolicyRequest {
    
    const filterSensitiveLog: (obj: DeleteRolePolicyRequest) => any;
}
export interface DeleteSAMLProviderRequest {
    
    SAMLProviderArn: string | undefined;
}
export declare namespace DeleteSAMLProviderRequest {
    
    const filterSensitiveLog: (obj: DeleteSAMLProviderRequest) => any;
}
export interface DeleteServerCertificateRequest {
    
    ServerCertificateName: string | undefined;
}
export declare namespace DeleteServerCertificateRequest {
    
    const filterSensitiveLog: (obj: DeleteServerCertificateRequest) => any;
}
export interface DeleteServiceLinkedRoleRequest {
    
    RoleName: string | undefined;
}
export declare namespace DeleteServiceLinkedRoleRequest {
    
    const filterSensitiveLog: (obj: DeleteServiceLinkedRoleRequest) => any;
}
export interface DeleteServiceLinkedRoleResponse {
    
    DeletionTaskId: string | undefined;
}
export declare namespace DeleteServiceLinkedRoleResponse {
    
    const filterSensitiveLog: (obj: DeleteServiceLinkedRoleResponse) => any;
}
export interface DeleteServiceSpecificCredentialRequest {
    
    UserName?: string;
    
    ServiceSpecificCredentialId: string | undefined;
}
export declare namespace DeleteServiceSpecificCredentialRequest {
    
    const filterSensitiveLog: (obj: DeleteServiceSpecificCredentialRequest) => any;
}
export interface DeleteSigningCertificateRequest {
    
    UserName?: string;
    
    CertificateId: string | undefined;
}
export declare namespace DeleteSigningCertificateRequest {
    
    const filterSensitiveLog: (obj: DeleteSigningCertificateRequest) => any;
}
export interface DeleteSSHPublicKeyRequest {
    
    UserName: string | undefined;
    
    SSHPublicKeyId: string | undefined;
}
export declare namespace DeleteSSHPublicKeyRequest {
    
    const filterSensitiveLog: (obj: DeleteSSHPublicKeyRequest) => any;
}
export interface DeleteUserRequest {
    
    UserName: string | undefined;
}
export declare namespace DeleteUserRequest {
    
    const filterSensitiveLog: (obj: DeleteUserRequest) => any;
}
export interface DeleteUserPermissionsBoundaryRequest {
    
    UserName: string | undefined;
}
export declare namespace DeleteUserPermissionsBoundaryRequest {
    
    const filterSensitiveLog: (obj: DeleteUserPermissionsBoundaryRequest) => any;
}
export interface DeleteUserPolicyRequest {
    
    UserName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace DeleteUserPolicyRequest {
    
    const filterSensitiveLog: (obj: DeleteUserPolicyRequest) => any;
}
export interface DeleteVirtualMFADeviceRequest {
    
    SerialNumber: string | undefined;
}
export declare namespace DeleteVirtualMFADeviceRequest {
    
    const filterSensitiveLog: (obj: DeleteVirtualMFADeviceRequest) => any;
}
export interface DetachGroupPolicyRequest {
    
    GroupName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace DetachGroupPolicyRequest {
    
    const filterSensitiveLog: (obj: DetachGroupPolicyRequest) => any;
}
export interface DetachRolePolicyRequest {
    
    RoleName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace DetachRolePolicyRequest {
    
    const filterSensitiveLog: (obj: DetachRolePolicyRequest) => any;
}
export interface DetachUserPolicyRequest {
    
    UserName: string | undefined;
    
    PolicyArn: string | undefined;
}
export declare namespace DetachUserPolicyRequest {
    
    const filterSensitiveLog: (obj: DetachUserPolicyRequest) => any;
}
export interface EnableMFADeviceRequest {
    
    UserName: string | undefined;
    
    SerialNumber: string | undefined;
    
    AuthenticationCode1: string | undefined;
    
    AuthenticationCode2: string | undefined;
}
export declare namespace EnableMFADeviceRequest {
    
    const filterSensitiveLog: (obj: EnableMFADeviceRequest) => any;
}

export declare class InvalidAuthenticationCodeException extends __BaseException {
    readonly name: "InvalidAuthenticationCodeException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidAuthenticationCodeException, __BaseException>);
}
export declare enum ReportStateType {
    COMPLETE = "COMPLETE",
    INPROGRESS = "INPROGRESS",
    STARTED = "STARTED"
}

export interface GenerateCredentialReportResponse {
    
    State?: ReportStateType | string;
    
    Description?: string;
}
export declare namespace GenerateCredentialReportResponse {
    
    const filterSensitiveLog: (obj: GenerateCredentialReportResponse) => any;
}
export interface GenerateOrganizationsAccessReportRequest {
    
    EntityPath: string | undefined;
    
    OrganizationsPolicyId?: string;
}
export declare namespace GenerateOrganizationsAccessReportRequest {
    
    const filterSensitiveLog: (obj: GenerateOrganizationsAccessReportRequest) => any;
}
export interface GenerateOrganizationsAccessReportResponse {
    
    JobId?: string;
}
export declare namespace GenerateOrganizationsAccessReportResponse {
    
    const filterSensitiveLog: (obj: GenerateOrganizationsAccessReportResponse) => any;
}

export declare class ReportGenerationLimitExceededException extends __BaseException {
    readonly name: "ReportGenerationLimitExceededException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ReportGenerationLimitExceededException, __BaseException>);
}
export interface GenerateServiceLastAccessedDetailsRequest {
    
    Arn: string | undefined;
    
    Granularity?: AccessAdvisorUsageGranularityType | string;
}
export declare namespace GenerateServiceLastAccessedDetailsRequest {
    
    const filterSensitiveLog: (obj: GenerateServiceLastAccessedDetailsRequest) => any;
}
export interface GenerateServiceLastAccessedDetailsResponse {
    
    JobId?: string;
}
export declare namespace GenerateServiceLastAccessedDetailsResponse {
    
    const filterSensitiveLog: (obj: GenerateServiceLastAccessedDetailsResponse) => any;
}
export interface GetAccessKeyLastUsedRequest {
    
    AccessKeyId: string | undefined;
}
export declare namespace GetAccessKeyLastUsedRequest {
    
    const filterSensitiveLog: (obj: GetAccessKeyLastUsedRequest) => any;
}

export interface GetAccessKeyLastUsedResponse {
    
    UserName?: string;
    
    AccessKeyLastUsed?: AccessKeyLastUsed;
}
export declare namespace GetAccessKeyLastUsedResponse {
    
    const filterSensitiveLog: (obj: GetAccessKeyLastUsedResponse) => any;
}
export declare enum EntityType {
    AWSManagedPolicy = "AWSManagedPolicy",
    Group = "Group",
    LocalManagedPolicy = "LocalManagedPolicy",
    Role = "Role",
    User = "User"
}
export interface GetAccountAuthorizationDetailsRequest {
    
    Filter?: (EntityType | string)[];
    
    MaxItems?: number;
    
    Marker?: string;
}
export declare namespace GetAccountAuthorizationDetailsRequest {
    
    const filterSensitiveLog: (obj: GetAccountAuthorizationDetailsRequest) => any;
}

export interface PolicyDetail {
    
    PolicyName?: string;
    
    PolicyDocument?: string;
}
export declare namespace PolicyDetail {
    
    const filterSensitiveLog: (obj: PolicyDetail) => any;
}

export interface GroupDetail {
    
    Path?: string;
    
    GroupName?: string;
    
    GroupId?: string;
    
    Arn?: string;
    
    CreateDate?: Date;
    
    GroupPolicyList?: PolicyDetail[];
    
    AttachedManagedPolicies?: AttachedPolicy[];
}
export declare namespace GroupDetail {
    
    const filterSensitiveLog: (obj: GroupDetail) => any;
}

export interface ManagedPolicyDetail {
    
    PolicyName?: string;
    
    PolicyId?: string;
    
    Arn?: string;
    
    Path?: string;
    
    DefaultVersionId?: string;
    
    AttachmentCount?: number;
    
    PermissionsBoundaryUsageCount?: number;
    
    IsAttachable?: boolean;
    
    Description?: string;
    
    CreateDate?: Date;
    
    UpdateDate?: Date;
    
    PolicyVersionList?: PolicyVersion[];
}
export declare namespace ManagedPolicyDetail {
    
    const filterSensitiveLog: (obj: ManagedPolicyDetail) => any;
}

export interface RoleDetail {
    
    Path?: string;
    
    RoleName?: string;
    
    RoleId?: string;
    
    Arn?: string;
    
    CreateDate?: Date;
    
    AssumeRolePolicyDocument?: string;
    
    InstanceProfileList?: InstanceProfile[];
    
    RolePolicyList?: PolicyDetail[];
    
    AttachedManagedPolicies?: AttachedPolicy[];
    
    PermissionsBoundary?: AttachedPermissionsBoundary;
    
    Tags?: Tag[];
    
    RoleLastUsed?: RoleLastUsed;
}
export declare namespace RoleDetail {
    
    const filterSensitiveLog: (obj: RoleDetail) => any;
}

export interface UserDetail {
    
    Path?: string;
    
    UserName?: string;
    
    UserId?: string;
    
    Arn?: string;
    
    CreateDate?: Date;
    
    UserPolicyList?: PolicyDetail[];
    
    GroupList?: string[];
    
    AttachedManagedPolicies?: AttachedPolicy[];
    
    PermissionsBoundary?: AttachedPermissionsBoundary;
    
    Tags?: Tag[];
}
export declare namespace UserDetail {
    
    const filterSensitiveLog: (obj: UserDetail) => any;
}

export interface GetAccountAuthorizationDetailsResponse {
    
    UserDetailList?: UserDetail[];
    
    GroupDetailList?: GroupDetail[];
    
    RoleDetailList?: RoleDetail[];
    
    Policies?: ManagedPolicyDetail[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace GetAccountAuthorizationDetailsResponse {
    
    const filterSensitiveLog: (obj: GetAccountAuthorizationDetailsResponse) => any;
}

export interface PasswordPolicy {
    
    MinimumPasswordLength?: number;
    
    RequireSymbols?: boolean;
    
    RequireNumbers?: boolean;
    
    RequireUppercaseCharacters?: boolean;
    
    RequireLowercaseCharacters?: boolean;
    
    AllowUsersToChangePassword?: boolean;
    
    ExpirePasswords?: boolean;
    
    MaxPasswordAge?: number;
    
    PasswordReusePrevention?: number;
    
    HardExpiry?: boolean;
}
export declare namespace PasswordPolicy {
    
    const filterSensitiveLog: (obj: PasswordPolicy) => any;
}

export interface GetAccountPasswordPolicyResponse {
    
    PasswordPolicy: PasswordPolicy | undefined;
}
export declare namespace GetAccountPasswordPolicyResponse {
    
    const filterSensitiveLog: (obj: GetAccountPasswordPolicyResponse) => any;
}
export declare type SummaryKeyType = "AccessKeysPerUserQuota" | "AccountAccessKeysPresent" | "AccountMFAEnabled" | "AccountSigningCertificatesPresent" | "AttachedPoliciesPerGroupQuota" | "AttachedPoliciesPerRoleQuota" | "AttachedPoliciesPerUserQuota" | "GlobalEndpointTokenVersion" | "GroupPolicySizeQuota" | "Groups" | "GroupsPerUserQuota" | "GroupsQuota" | "MFADevices" | "MFADevicesInUse" | "Policies" | "PoliciesQuota" | "PolicySizeQuota" | "PolicyVersionsInUse" | "PolicyVersionsInUseQuota" | "ServerCertificates" | "ServerCertificatesQuota" | "SigningCertificatesPerUserQuota" | "UserPolicySizeQuota" | "Users" | "UsersQuota" | "VersionsPerPolicyQuota";

export interface GetAccountSummaryResponse {
    
    SummaryMap?: {
        [key: string]: number;
    };
}
export declare namespace GetAccountSummaryResponse {
    
    const filterSensitiveLog: (obj: GetAccountSummaryResponse) => any;
}
export interface GetContextKeysForCustomPolicyRequest {
    
    PolicyInputList: string[] | undefined;
}
export declare namespace GetContextKeysForCustomPolicyRequest {
    
    const filterSensitiveLog: (obj: GetContextKeysForCustomPolicyRequest) => any;
}

export interface GetContextKeysForPolicyResponse {
    
    ContextKeyNames?: string[];
}
export declare namespace GetContextKeysForPolicyResponse {
    
    const filterSensitiveLog: (obj: GetContextKeysForPolicyResponse) => any;
}
export interface GetContextKeysForPrincipalPolicyRequest {
    
    PolicySourceArn: string | undefined;
    
    PolicyInputList?: string[];
}
export declare namespace GetContextKeysForPrincipalPolicyRequest {
    
    const filterSensitiveLog: (obj: GetContextKeysForPrincipalPolicyRequest) => any;
}

export declare class CredentialReportExpiredException extends __BaseException {
    readonly name: "CredentialReportExpiredException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<CredentialReportExpiredException, __BaseException>);
}

export declare class CredentialReportNotPresentException extends __BaseException {
    readonly name: "CredentialReportNotPresentException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<CredentialReportNotPresentException, __BaseException>);
}

export declare class CredentialReportNotReadyException extends __BaseException {
    readonly name: "CredentialReportNotReadyException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<CredentialReportNotReadyException, __BaseException>);
}
export declare type ReportFormatType = "text/csv";

export interface GetCredentialReportResponse {
    
    Content?: Uint8Array;
    
    ReportFormat?: ReportFormatType | string;
    
    GeneratedTime?: Date;
}
export declare namespace GetCredentialReportResponse {
    
    const filterSensitiveLog: (obj: GetCredentialReportResponse) => any;
}
export interface GetGroupRequest {
    
    GroupName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace GetGroupRequest {
    
    const filterSensitiveLog: (obj: GetGroupRequest) => any;
}

export interface GetGroupResponse {
    
    Group: Group | undefined;
    
    Users: User[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace GetGroupResponse {
    
    const filterSensitiveLog: (obj: GetGroupResponse) => any;
}
export interface GetGroupPolicyRequest {
    
    GroupName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace GetGroupPolicyRequest {
    
    const filterSensitiveLog: (obj: GetGroupPolicyRequest) => any;
}

export interface GetGroupPolicyResponse {
    
    GroupName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace GetGroupPolicyResponse {
    
    const filterSensitiveLog: (obj: GetGroupPolicyResponse) => any;
}
export interface GetInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
}
export declare namespace GetInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: GetInstanceProfileRequest) => any;
}

export interface GetInstanceProfileResponse {
    
    InstanceProfile: InstanceProfile | undefined;
}
export declare namespace GetInstanceProfileResponse {
    
    const filterSensitiveLog: (obj: GetInstanceProfileResponse) => any;
}
export interface GetLoginProfileRequest {
    
    UserName: string | undefined;
}
export declare namespace GetLoginProfileRequest {
    
    const filterSensitiveLog: (obj: GetLoginProfileRequest) => any;
}

export interface GetLoginProfileResponse {
    
    LoginProfile: LoginProfile | undefined;
}
export declare namespace GetLoginProfileResponse {
    
    const filterSensitiveLog: (obj: GetLoginProfileResponse) => any;
}
export interface GetOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
}
export declare namespace GetOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: GetOpenIDConnectProviderRequest) => any;
}

export interface GetOpenIDConnectProviderResponse {
    
    Url?: string;
    
    ClientIDList?: string[];
    
    ThumbprintList?: string[];
    
    CreateDate?: Date;
    
    Tags?: Tag[];
}
export declare namespace GetOpenIDConnectProviderResponse {
    
    const filterSensitiveLog: (obj: GetOpenIDConnectProviderResponse) => any;
}
export declare enum 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"
}
export interface GetOrganizationsAccessReportRequest {
    
    JobId: string | undefined;
    
    MaxItems?: number;
    
    Marker?: string;
    
    SortKey?: SortKeyType | string;
}
export declare namespace GetOrganizationsAccessReportRequest {
    
    const filterSensitiveLog: (obj: GetOrganizationsAccessReportRequest) => any;
}

export interface ErrorDetails {
    
    Message: string | undefined;
    
    Code: string | undefined;
}
export declare namespace ErrorDetails {
    
    const filterSensitiveLog: (obj: ErrorDetails) => any;
}
export declare type JobStatusType = "COMPLETED" | "FAILED" | "IN_PROGRESS";
export interface GetOrganizationsAccessReportResponse {
    
    JobStatus: JobStatusType | string | undefined;
    
    JobCreationDate: Date | undefined;
    
    JobCompletionDate?: Date;
    
    NumberOfServicesAccessible?: number;
    
    NumberOfServicesNotAccessed?: number;
    
    AccessDetails?: AccessDetail[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
    
    ErrorDetails?: ErrorDetails;
}
export declare namespace GetOrganizationsAccessReportResponse {
    
    const filterSensitiveLog: (obj: GetOrganizationsAccessReportResponse) => any;
}
export interface GetPolicyRequest {
    
    PolicyArn: string | undefined;
}
export declare namespace GetPolicyRequest {
    
    const filterSensitiveLog: (obj: GetPolicyRequest) => any;
}

export interface GetPolicyResponse {
    
    Policy?: Policy;
}
export declare namespace GetPolicyResponse {
    
    const filterSensitiveLog: (obj: GetPolicyResponse) => any;
}
export interface GetPolicyVersionRequest {
    
    PolicyArn: string | undefined;
    
    VersionId: string | undefined;
}
export declare namespace GetPolicyVersionRequest {
    
    const filterSensitiveLog: (obj: GetPolicyVersionRequest) => any;
}

export interface GetPolicyVersionResponse {
    
    PolicyVersion?: PolicyVersion;
}
export declare namespace GetPolicyVersionResponse {
    
    const filterSensitiveLog: (obj: GetPolicyVersionResponse) => any;
}
export interface GetRoleRequest {
    
    RoleName: string | undefined;
}
export declare namespace GetRoleRequest {
    
    const filterSensitiveLog: (obj: GetRoleRequest) => any;
}

export interface GetRoleResponse {
    
    Role: Role | undefined;
}
export declare namespace GetRoleResponse {
    
    const filterSensitiveLog: (obj: GetRoleResponse) => any;
}
export interface GetRolePolicyRequest {
    
    RoleName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace GetRolePolicyRequest {
    
    const filterSensitiveLog: (obj: GetRolePolicyRequest) => any;
}

export interface GetRolePolicyResponse {
    
    RoleName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace GetRolePolicyResponse {
    
    const filterSensitiveLog: (obj: GetRolePolicyResponse) => any;
}
export interface GetSAMLProviderRequest {
    
    SAMLProviderArn: string | undefined;
}
export declare namespace GetSAMLProviderRequest {
    
    const filterSensitiveLog: (obj: GetSAMLProviderRequest) => any;
}

export interface GetSAMLProviderResponse {
    
    SAMLMetadataDocument?: string;
    
    CreateDate?: Date;
    
    ValidUntil?: Date;
    
    Tags?: Tag[];
}
export declare namespace GetSAMLProviderResponse {
    
    const filterSensitiveLog: (obj: GetSAMLProviderResponse) => any;
}
export interface GetServerCertificateRequest {
    
    ServerCertificateName: string | undefined;
}
export declare namespace GetServerCertificateRequest {
    
    const filterSensitiveLog: (obj: GetServerCertificateRequest) => any;
}

export interface ServerCertificateMetadata {
    
    Path: string | undefined;
    
    ServerCertificateName: string | undefined;
    
    ServerCertificateId: string | undefined;
    
    Arn: string | undefined;
    
    UploadDate?: Date;
    
    Expiration?: Date;
}
export declare namespace ServerCertificateMetadata {
    
    const filterSensitiveLog: (obj: ServerCertificateMetadata) => any;
}

export interface ServerCertificate {
    
    ServerCertificateMetadata: ServerCertificateMetadata | undefined;
    
    CertificateBody: string | undefined;
    
    CertificateChain?: string;
    
    Tags?: Tag[];
}
export declare namespace ServerCertificate {
    
    const filterSensitiveLog: (obj: ServerCertificate) => any;
}

export interface GetServerCertificateResponse {
    
    ServerCertificate: ServerCertificate | undefined;
}
export declare namespace GetServerCertificateResponse {
    
    const filterSensitiveLog: (obj: GetServerCertificateResponse) => any;
}
export interface GetServiceLastAccessedDetailsRequest {
    
    JobId: string | undefined;
    
    MaxItems?: number;
    
    Marker?: string;
}
export declare namespace GetServiceLastAccessedDetailsRequest {
    
    const filterSensitiveLog: (obj: GetServiceLastAccessedDetailsRequest) => any;
}

export interface TrackedActionLastAccessed {
    
    ActionName?: string;
    
    LastAccessedEntity?: string;
    
    LastAccessedTime?: Date;
    
    LastAccessedRegion?: string;
}
export declare namespace TrackedActionLastAccessed {
    
    const filterSensitiveLog: (obj: TrackedActionLastAccessed) => any;
}

export interface ServiceLastAccessed {
    
    ServiceName: string | undefined;
    
    LastAuthenticated?: Date;
    
    ServiceNamespace: string | undefined;
    
    LastAuthenticatedEntity?: string;
    
    LastAuthenticatedRegion?: string;
    
    TotalAuthenticatedEntities?: number;
    
    TrackedActionsLastAccessed?: TrackedActionLastAccessed[];
}
export declare namespace ServiceLastAccessed {
    
    const filterSensitiveLog: (obj: ServiceLastAccessed) => any;
}
export interface GetServiceLastAccessedDetailsResponse {
    
    JobStatus: JobStatusType | string | undefined;
    
    JobType?: AccessAdvisorUsageGranularityType | string;
    
    JobCreationDate: Date | undefined;
    
    ServicesLastAccessed: ServiceLastAccessed[] | undefined;
    
    JobCompletionDate: Date | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
    
    Error?: ErrorDetails;
}
export declare namespace GetServiceLastAccessedDetailsResponse {
    
    const filterSensitiveLog: (obj: GetServiceLastAccessedDetailsResponse) => any;
}
export interface GetServiceLastAccessedDetailsWithEntitiesRequest {
    
    JobId: string | undefined;
    
    ServiceNamespace: string | undefined;
    
    MaxItems?: number;
    
    Marker?: string;
}
export declare namespace GetServiceLastAccessedDetailsWithEntitiesRequest {
    
    const filterSensitiveLog: (obj: GetServiceLastAccessedDetailsWithEntitiesRequest) => any;
}
export declare enum PolicyOwnerEntityType {
    GROUP = "GROUP",
    ROLE = "ROLE",
    USER = "USER"
}

export interface EntityInfo {
    
    Arn: string | undefined;
    
    Name: string | undefined;
    
    Type: PolicyOwnerEntityType | string | undefined;
    
    Id: string | undefined;
    
    Path?: string;
}
export declare namespace EntityInfo {
    
    const filterSensitiveLog: (obj: EntityInfo) => any;
}

export interface EntityDetails {
    
    EntityInfo: EntityInfo | undefined;
    
    LastAuthenticated?: Date;
}
export declare namespace EntityDetails {
    
    const filterSensitiveLog: (obj: EntityDetails) => any;
}
export interface GetServiceLastAccessedDetailsWithEntitiesResponse {
    
    JobStatus: JobStatusType | string | undefined;
    
    JobCreationDate: Date | undefined;
    
    JobCompletionDate: Date | undefined;
    
    EntityDetailsList: EntityDetails[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
    
    Error?: ErrorDetails;
}
export declare namespace GetServiceLastAccessedDetailsWithEntitiesResponse {
    
    const filterSensitiveLog: (obj: GetServiceLastAccessedDetailsWithEntitiesResponse) => any;
}
export interface GetServiceLinkedRoleDeletionStatusRequest {
    
    DeletionTaskId: string | undefined;
}
export declare namespace GetServiceLinkedRoleDeletionStatusRequest {
    
    const filterSensitiveLog: (obj: GetServiceLinkedRoleDeletionStatusRequest) => any;
}

export interface RoleUsageType {
    
    Region?: string;
    
    Resources?: string[];
}
export declare namespace RoleUsageType {
    
    const filterSensitiveLog: (obj: RoleUsageType) => any;
}

export interface DeletionTaskFailureReasonType {
    
    Reason?: string;
    
    RoleUsageList?: RoleUsageType[];
}
export declare namespace DeletionTaskFailureReasonType {
    
    const filterSensitiveLog: (obj: DeletionTaskFailureReasonType) => any;
}
export declare enum DeletionTaskStatusType {
    FAILED = "FAILED",
    IN_PROGRESS = "IN_PROGRESS",
    NOT_STARTED = "NOT_STARTED",
    SUCCEEDED = "SUCCEEDED"
}
export interface GetServiceLinkedRoleDeletionStatusResponse {
    
    Status: DeletionTaskStatusType | string | undefined;
    
    Reason?: DeletionTaskFailureReasonType;
}
export declare namespace GetServiceLinkedRoleDeletionStatusResponse {
    
    const filterSensitiveLog: (obj: GetServiceLinkedRoleDeletionStatusResponse) => any;
}
export declare type EncodingType = "PEM" | "SSH";
export interface GetSSHPublicKeyRequest {
    
    UserName: string | undefined;
    
    SSHPublicKeyId: string | undefined;
    
    Encoding: EncodingType | string | undefined;
}
export declare namespace GetSSHPublicKeyRequest {
    
    const filterSensitiveLog: (obj: GetSSHPublicKeyRequest) => any;
}

export interface SSHPublicKey {
    
    UserName: string | undefined;
    
    SSHPublicKeyId: string | undefined;
    
    Fingerprint: string | undefined;
    
    SSHPublicKeyBody: string | undefined;
    
    Status: StatusType | string | undefined;
    
    UploadDate?: Date;
}
export declare namespace SSHPublicKey {
    
    const filterSensitiveLog: (obj: SSHPublicKey) => any;
}

export interface GetSSHPublicKeyResponse {
    
    SSHPublicKey?: SSHPublicKey;
}
export declare namespace GetSSHPublicKeyResponse {
    
    const filterSensitiveLog: (obj: GetSSHPublicKeyResponse) => any;
}

export declare class UnrecognizedPublicKeyEncodingException extends __BaseException {
    readonly name: "UnrecognizedPublicKeyEncodingException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<UnrecognizedPublicKeyEncodingException, __BaseException>);
}
export interface GetUserRequest {
    
    UserName?: string;
}
export declare namespace GetUserRequest {
    
    const filterSensitiveLog: (obj: GetUserRequest) => any;
}

export interface GetUserResponse {
    
    User: User | undefined;
}
export declare namespace GetUserResponse {
    
    const filterSensitiveLog: (obj: GetUserResponse) => any;
}
export interface GetUserPolicyRequest {
    
    UserName: string | undefined;
    
    PolicyName: string | undefined;
}
export declare namespace GetUserPolicyRequest {
    
    const filterSensitiveLog: (obj: GetUserPolicyRequest) => any;
}

export interface GetUserPolicyResponse {
    
    UserName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace GetUserPolicyResponse {
    
    const filterSensitiveLog: (obj: GetUserPolicyResponse) => any;
}
export interface ListAccessKeysRequest {
    
    UserName?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListAccessKeysRequest {
    
    const filterSensitiveLog: (obj: ListAccessKeysRequest) => any;
}

export interface ListAccessKeysResponse {
    
    AccessKeyMetadata: AccessKeyMetadata[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListAccessKeysResponse {
    
    const filterSensitiveLog: (obj: ListAccessKeysResponse) => any;
}
export interface ListAccountAliasesRequest {
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListAccountAliasesRequest {
    
    const filterSensitiveLog: (obj: ListAccountAliasesRequest) => any;
}

export interface ListAccountAliasesResponse {
    
    AccountAliases: string[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListAccountAliasesResponse {
    
    const filterSensitiveLog: (obj: ListAccountAliasesResponse) => any;
}
export interface ListAttachedGroupPoliciesRequest {
    
    GroupName: string | undefined;
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListAttachedGroupPoliciesRequest {
    
    const filterSensitiveLog: (obj: ListAttachedGroupPoliciesRequest) => any;
}

export interface ListAttachedGroupPoliciesResponse {
    
    AttachedPolicies?: AttachedPolicy[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListAttachedGroupPoliciesResponse {
    
    const filterSensitiveLog: (obj: ListAttachedGroupPoliciesResponse) => any;
}
export interface ListAttachedRolePoliciesRequest {
    
    RoleName: string | undefined;
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListAttachedRolePoliciesRequest {
    
    const filterSensitiveLog: (obj: ListAttachedRolePoliciesRequest) => any;
}

export interface ListAttachedRolePoliciesResponse {
    
    AttachedPolicies?: AttachedPolicy[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListAttachedRolePoliciesResponse {
    
    const filterSensitiveLog: (obj: ListAttachedRolePoliciesResponse) => any;
}
export interface ListAttachedUserPoliciesRequest {
    
    UserName: string | undefined;
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListAttachedUserPoliciesRequest {
    
    const filterSensitiveLog: (obj: ListAttachedUserPoliciesRequest) => any;
}

export interface ListAttachedUserPoliciesResponse {
    
    AttachedPolicies?: AttachedPolicy[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListAttachedUserPoliciesResponse {
    
    const filterSensitiveLog: (obj: ListAttachedUserPoliciesResponse) => any;
}
export declare type PolicyUsageType = "PermissionsBoundary" | "PermissionsPolicy";
export interface ListEntitiesForPolicyRequest {
    
    PolicyArn: string | undefined;
    
    EntityFilter?: EntityType | string;
    
    PathPrefix?: string;
    
    PolicyUsageFilter?: PolicyUsageType | string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListEntitiesForPolicyRequest {
    
    const filterSensitiveLog: (obj: ListEntitiesForPolicyRequest) => any;
}

export interface PolicyGroup {
    
    GroupName?: string;
    
    GroupId?: string;
}
export declare namespace PolicyGroup {
    
    const filterSensitiveLog: (obj: PolicyGroup) => any;
}

export interface PolicyRole {
    
    RoleName?: string;
    
    RoleId?: string;
}
export declare namespace PolicyRole {
    
    const filterSensitiveLog: (obj: PolicyRole) => any;
}

export interface PolicyUser {
    
    UserName?: string;
    
    UserId?: string;
}
export declare namespace PolicyUser {
    
    const filterSensitiveLog: (obj: PolicyUser) => any;
}

export interface ListEntitiesForPolicyResponse {
    
    PolicyGroups?: PolicyGroup[];
    
    PolicyUsers?: PolicyUser[];
    
    PolicyRoles?: PolicyRole[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListEntitiesForPolicyResponse {
    
    const filterSensitiveLog: (obj: ListEntitiesForPolicyResponse) => any;
}
export interface ListGroupPoliciesRequest {
    
    GroupName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListGroupPoliciesRequest {
    
    const filterSensitiveLog: (obj: ListGroupPoliciesRequest) => any;
}

export interface ListGroupPoliciesResponse {
    
    PolicyNames: string[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListGroupPoliciesResponse {
    
    const filterSensitiveLog: (obj: ListGroupPoliciesResponse) => any;
}
export interface ListGroupsRequest {
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListGroupsRequest {
    
    const filterSensitiveLog: (obj: ListGroupsRequest) => any;
}

export interface ListGroupsResponse {
    
    Groups: Group[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListGroupsResponse {
    
    const filterSensitiveLog: (obj: ListGroupsResponse) => any;
}
export interface ListGroupsForUserRequest {
    
    UserName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListGroupsForUserRequest {
    
    const filterSensitiveLog: (obj: ListGroupsForUserRequest) => any;
}

export interface ListGroupsForUserResponse {
    
    Groups: Group[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListGroupsForUserResponse {
    
    const filterSensitiveLog: (obj: ListGroupsForUserResponse) => any;
}
export interface ListInstanceProfilesRequest {
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListInstanceProfilesRequest {
    
    const filterSensitiveLog: (obj: ListInstanceProfilesRequest) => any;
}

export interface ListInstanceProfilesResponse {
    
    InstanceProfiles: InstanceProfile[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListInstanceProfilesResponse {
    
    const filterSensitiveLog: (obj: ListInstanceProfilesResponse) => any;
}
export interface ListInstanceProfilesForRoleRequest {
    
    RoleName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListInstanceProfilesForRoleRequest {
    
    const filterSensitiveLog: (obj: ListInstanceProfilesForRoleRequest) => any;
}

export interface ListInstanceProfilesForRoleResponse {
    
    InstanceProfiles: InstanceProfile[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListInstanceProfilesForRoleResponse {
    
    const filterSensitiveLog: (obj: ListInstanceProfilesForRoleResponse) => any;
}
export interface ListInstanceProfileTagsRequest {
    
    InstanceProfileName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListInstanceProfileTagsRequest {
    
    const filterSensitiveLog: (obj: ListInstanceProfileTagsRequest) => any;
}
export interface ListInstanceProfileTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListInstanceProfileTagsResponse {
    
    const filterSensitiveLog: (obj: ListInstanceProfileTagsResponse) => any;
}
export interface ListMFADevicesRequest {
    
    UserName?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListMFADevicesRequest {
    
    const filterSensitiveLog: (obj: ListMFADevicesRequest) => any;
}

export interface MFADevice {
    
    UserName: string | undefined;
    
    SerialNumber: string | undefined;
    
    EnableDate: Date | undefined;
}
export declare namespace MFADevice {
    
    const filterSensitiveLog: (obj: MFADevice) => any;
}

export interface ListMFADevicesResponse {
    
    MFADevices: MFADevice[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListMFADevicesResponse {
    
    const filterSensitiveLog: (obj: ListMFADevicesResponse) => any;
}
export interface ListMFADeviceTagsRequest {
    
    SerialNumber: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListMFADeviceTagsRequest {
    
    const filterSensitiveLog: (obj: ListMFADeviceTagsRequest) => any;
}
export interface ListMFADeviceTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListMFADeviceTagsResponse {
    
    const filterSensitiveLog: (obj: ListMFADeviceTagsResponse) => any;
}
export interface ListOpenIDConnectProvidersRequest {
}
export declare namespace ListOpenIDConnectProvidersRequest {
    
    const filterSensitiveLog: (obj: ListOpenIDConnectProvidersRequest) => any;
}

export interface OpenIDConnectProviderListEntry {
    
    Arn?: string;
}
export declare namespace OpenIDConnectProviderListEntry {
    
    const filterSensitiveLog: (obj: OpenIDConnectProviderListEntry) => any;
}

export interface ListOpenIDConnectProvidersResponse {
    
    OpenIDConnectProviderList?: OpenIDConnectProviderListEntry[];
}
export declare namespace ListOpenIDConnectProvidersResponse {
    
    const filterSensitiveLog: (obj: ListOpenIDConnectProvidersResponse) => any;
}
export interface ListOpenIDConnectProviderTagsRequest {
    
    OpenIDConnectProviderArn: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListOpenIDConnectProviderTagsRequest {
    
    const filterSensitiveLog: (obj: ListOpenIDConnectProviderTagsRequest) => any;
}
export interface ListOpenIDConnectProviderTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListOpenIDConnectProviderTagsResponse {
    
    const filterSensitiveLog: (obj: ListOpenIDConnectProviderTagsResponse) => any;
}
export declare enum PolicyScopeType {
    AWS = "AWS",
    All = "All",
    Local = "Local"
}
export interface ListPoliciesRequest {
    
    Scope?: PolicyScopeType | string;
    
    OnlyAttached?: boolean;
    
    PathPrefix?: string;
    
    PolicyUsageFilter?: PolicyUsageType | string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListPoliciesRequest {
    
    const filterSensitiveLog: (obj: ListPoliciesRequest) => any;
}

export interface ListPoliciesResponse {
    
    Policies?: Policy[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListPoliciesResponse {
    
    const filterSensitiveLog: (obj: ListPoliciesResponse) => any;
}
export interface ListPoliciesGrantingServiceAccessRequest {
    
    Marker?: string;
    
    Arn: string | undefined;
    
    ServiceNamespaces: string[] | undefined;
}
export declare namespace ListPoliciesGrantingServiceAccessRequest {
    
    const filterSensitiveLog: (obj: ListPoliciesGrantingServiceAccessRequest) => any;
}
export declare enum PolicyType {
    INLINE = "INLINE",
    MANAGED = "MANAGED"
}

export interface PolicyGrantingServiceAccess {
    
    PolicyName: string | undefined;
    
    PolicyType: PolicyType | string | undefined;
    
    PolicyArn?: string;
    
    EntityType?: PolicyOwnerEntityType | string;
    
    EntityName?: string;
}
export declare namespace PolicyGrantingServiceAccess {
    
    const filterSensitiveLog: (obj: PolicyGrantingServiceAccess) => any;
}

export interface ListPoliciesGrantingServiceAccessEntry {
    
    ServiceNamespace?: string;
    
    Policies?: PolicyGrantingServiceAccess[];
}
export declare namespace ListPoliciesGrantingServiceAccessEntry {
    
    const filterSensitiveLog: (obj: ListPoliciesGrantingServiceAccessEntry) => any;
}
export interface ListPoliciesGrantingServiceAccessResponse {
    
    PoliciesGrantingServiceAccess: ListPoliciesGrantingServiceAccessEntry[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListPoliciesGrantingServiceAccessResponse {
    
    const filterSensitiveLog: (obj: ListPoliciesGrantingServiceAccessResponse) => any;
}
export interface ListPolicyTagsRequest {
    
    PolicyArn: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListPolicyTagsRequest {
    
    const filterSensitiveLog: (obj: ListPolicyTagsRequest) => any;
}
export interface ListPolicyTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListPolicyTagsResponse {
    
    const filterSensitiveLog: (obj: ListPolicyTagsResponse) => any;
}
export interface ListPolicyVersionsRequest {
    
    PolicyArn: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListPolicyVersionsRequest {
    
    const filterSensitiveLog: (obj: ListPolicyVersionsRequest) => any;
}

export interface ListPolicyVersionsResponse {
    
    Versions?: PolicyVersion[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListPolicyVersionsResponse {
    
    const filterSensitiveLog: (obj: ListPolicyVersionsResponse) => any;
}
export interface ListRolePoliciesRequest {
    
    RoleName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListRolePoliciesRequest {
    
    const filterSensitiveLog: (obj: ListRolePoliciesRequest) => any;
}

export interface ListRolePoliciesResponse {
    
    PolicyNames: string[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListRolePoliciesResponse {
    
    const filterSensitiveLog: (obj: ListRolePoliciesResponse) => any;
}
export interface ListRolesRequest {
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListRolesRequest {
    
    const filterSensitiveLog: (obj: ListRolesRequest) => any;
}

export interface ListRolesResponse {
    
    Roles: Role[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListRolesResponse {
    
    const filterSensitiveLog: (obj: ListRolesResponse) => any;
}
export interface ListRoleTagsRequest {
    
    RoleName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListRoleTagsRequest {
    
    const filterSensitiveLog: (obj: ListRoleTagsRequest) => any;
}
export interface ListRoleTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListRoleTagsResponse {
    
    const filterSensitiveLog: (obj: ListRoleTagsResponse) => any;
}
export interface ListSAMLProvidersRequest {
}
export declare namespace ListSAMLProvidersRequest {
    
    const filterSensitiveLog: (obj: ListSAMLProvidersRequest) => any;
}

export interface SAMLProviderListEntry {
    
    Arn?: string;
    
    ValidUntil?: Date;
    
    CreateDate?: Date;
}
export declare namespace SAMLProviderListEntry {
    
    const filterSensitiveLog: (obj: SAMLProviderListEntry) => any;
}

export interface ListSAMLProvidersResponse {
    
    SAMLProviderList?: SAMLProviderListEntry[];
}
export declare namespace ListSAMLProvidersResponse {
    
    const filterSensitiveLog: (obj: ListSAMLProvidersResponse) => any;
}
export interface ListSAMLProviderTagsRequest {
    
    SAMLProviderArn: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListSAMLProviderTagsRequest {
    
    const filterSensitiveLog: (obj: ListSAMLProviderTagsRequest) => any;
}
export interface ListSAMLProviderTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListSAMLProviderTagsResponse {
    
    const filterSensitiveLog: (obj: ListSAMLProviderTagsResponse) => any;
}
export interface ListServerCertificatesRequest {
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListServerCertificatesRequest {
    
    const filterSensitiveLog: (obj: ListServerCertificatesRequest) => any;
}

export interface ListServerCertificatesResponse {
    
    ServerCertificateMetadataList: ServerCertificateMetadata[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListServerCertificatesResponse {
    
    const filterSensitiveLog: (obj: ListServerCertificatesResponse) => any;
}
export interface ListServerCertificateTagsRequest {
    
    ServerCertificateName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListServerCertificateTagsRequest {
    
    const filterSensitiveLog: (obj: ListServerCertificateTagsRequest) => any;
}
export interface ListServerCertificateTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListServerCertificateTagsResponse {
    
    const filterSensitiveLog: (obj: ListServerCertificateTagsResponse) => any;
}
export interface ListServiceSpecificCredentialsRequest {
    
    UserName?: string;
    
    ServiceName?: string;
}
export declare namespace ListServiceSpecificCredentialsRequest {
    
    const filterSensitiveLog: (obj: ListServiceSpecificCredentialsRequest) => any;
}

export interface ServiceSpecificCredentialMetadata {
    
    UserName: string | undefined;
    
    Status: StatusType | string | undefined;
    
    ServiceUserName: string | undefined;
    
    CreateDate: Date | undefined;
    
    ServiceSpecificCredentialId: string | undefined;
    
    ServiceName: string | undefined;
}
export declare namespace ServiceSpecificCredentialMetadata {
    
    const filterSensitiveLog: (obj: ServiceSpecificCredentialMetadata) => any;
}
export interface ListServiceSpecificCredentialsResponse {
    
    ServiceSpecificCredentials?: ServiceSpecificCredentialMetadata[];
}
export declare namespace ListServiceSpecificCredentialsResponse {
    
    const filterSensitiveLog: (obj: ListServiceSpecificCredentialsResponse) => any;
}
export interface ListSigningCertificatesRequest {
    
    UserName?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListSigningCertificatesRequest {
    
    const filterSensitiveLog: (obj: ListSigningCertificatesRequest) => any;
}

export interface SigningCertificate {
    
    UserName: string | undefined;
    
    CertificateId: string | undefined;
    
    CertificateBody: string | undefined;
    
    Status: StatusType | string | undefined;
    
    UploadDate?: Date;
}
export declare namespace SigningCertificate {
    
    const filterSensitiveLog: (obj: SigningCertificate) => any;
}

export interface ListSigningCertificatesResponse {
    
    Certificates: SigningCertificate[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListSigningCertificatesResponse {
    
    const filterSensitiveLog: (obj: ListSigningCertificatesResponse) => any;
}
export interface ListSSHPublicKeysRequest {
    
    UserName?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListSSHPublicKeysRequest {
    
    const filterSensitiveLog: (obj: ListSSHPublicKeysRequest) => any;
}

export interface SSHPublicKeyMetadata {
    
    UserName: string | undefined;
    
    SSHPublicKeyId: string | undefined;
    
    Status: StatusType | string | undefined;
    
    UploadDate: Date | undefined;
}
export declare namespace SSHPublicKeyMetadata {
    
    const filterSensitiveLog: (obj: SSHPublicKeyMetadata) => any;
}

export interface ListSSHPublicKeysResponse {
    
    SSHPublicKeys?: SSHPublicKeyMetadata[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListSSHPublicKeysResponse {
    
    const filterSensitiveLog: (obj: ListSSHPublicKeysResponse) => any;
}
export interface ListUserPoliciesRequest {
    
    UserName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListUserPoliciesRequest {
    
    const filterSensitiveLog: (obj: ListUserPoliciesRequest) => any;
}

export interface ListUserPoliciesResponse {
    
    PolicyNames: string[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListUserPoliciesResponse {
    
    const filterSensitiveLog: (obj: ListUserPoliciesResponse) => any;
}
export interface ListUsersRequest {
    
    PathPrefix?: string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListUsersRequest {
    
    const filterSensitiveLog: (obj: ListUsersRequest) => any;
}

export interface ListUsersResponse {
    
    Users: User[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListUsersResponse {
    
    const filterSensitiveLog: (obj: ListUsersResponse) => any;
}
export interface ListUserTagsRequest {
    
    UserName: string | undefined;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListUserTagsRequest {
    
    const filterSensitiveLog: (obj: ListUserTagsRequest) => any;
}
export interface ListUserTagsResponse {
    
    Tags: Tag[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListUserTagsResponse {
    
    const filterSensitiveLog: (obj: ListUserTagsResponse) => any;
}
export interface ListVirtualMFADevicesRequest {
    
    AssignmentStatus?: AssignmentStatusType | string;
    
    Marker?: string;
    
    MaxItems?: number;
}
export declare namespace ListVirtualMFADevicesRequest {
    
    const filterSensitiveLog: (obj: ListVirtualMFADevicesRequest) => any;
}

export interface ListVirtualMFADevicesResponse {
    
    VirtualMFADevices: VirtualMFADevice[] | undefined;
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace ListVirtualMFADevicesResponse {
    
    const filterSensitiveLog: (obj: ListVirtualMFADevicesResponse) => any;
}
export interface PutGroupPolicyRequest {
    
    GroupName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace PutGroupPolicyRequest {
    
    const filterSensitiveLog: (obj: PutGroupPolicyRequest) => any;
}
export interface PutRolePermissionsBoundaryRequest {
    
    RoleName: string | undefined;
    
    PermissionsBoundary: string | undefined;
}
export declare namespace PutRolePermissionsBoundaryRequest {
    
    const filterSensitiveLog: (obj: PutRolePermissionsBoundaryRequest) => any;
}
export interface PutRolePolicyRequest {
    
    RoleName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace PutRolePolicyRequest {
    
    const filterSensitiveLog: (obj: PutRolePolicyRequest) => any;
}
export interface PutUserPermissionsBoundaryRequest {
    
    UserName: string | undefined;
    
    PermissionsBoundary: string | undefined;
}
export declare namespace PutUserPermissionsBoundaryRequest {
    
    const filterSensitiveLog: (obj: PutUserPermissionsBoundaryRequest) => any;
}
export interface PutUserPolicyRequest {
    
    UserName: string | undefined;
    
    PolicyName: string | undefined;
    
    PolicyDocument: string | undefined;
}
export declare namespace PutUserPolicyRequest {
    
    const filterSensitiveLog: (obj: PutUserPolicyRequest) => any;
}
export interface RemoveClientIDFromOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
    
    ClientID: string | undefined;
}
export declare namespace RemoveClientIDFromOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: RemoveClientIDFromOpenIDConnectProviderRequest) => any;
}
export interface RemoveRoleFromInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
    
    RoleName: string | undefined;
}
export declare namespace RemoveRoleFromInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: RemoveRoleFromInstanceProfileRequest) => any;
}
export interface RemoveUserFromGroupRequest {
    
    GroupName: string | undefined;
    
    UserName: string | undefined;
}
export declare namespace RemoveUserFromGroupRequest {
    
    const filterSensitiveLog: (obj: RemoveUserFromGroupRequest) => any;
}
export interface ResetServiceSpecificCredentialRequest {
    
    UserName?: string;
    
    ServiceSpecificCredentialId: string | undefined;
}
export declare namespace ResetServiceSpecificCredentialRequest {
    
    const filterSensitiveLog: (obj: ResetServiceSpecificCredentialRequest) => any;
}
export interface ResetServiceSpecificCredentialResponse {
    
    ServiceSpecificCredential?: ServiceSpecificCredential;
}
export declare namespace ResetServiceSpecificCredentialResponse {
    
    const filterSensitiveLog: (obj: ResetServiceSpecificCredentialResponse) => any;
}
export interface ResyncMFADeviceRequest {
    
    UserName: string | undefined;
    
    SerialNumber: string | undefined;
    
    AuthenticationCode1: string | undefined;
    
    AuthenticationCode2: string | undefined;
}
export declare namespace ResyncMFADeviceRequest {
    
    const filterSensitiveLog: (obj: ResyncMFADeviceRequest) => any;
}
export interface SetDefaultPolicyVersionRequest {
    
    PolicyArn: string | undefined;
    
    VersionId: string | undefined;
}
export declare namespace SetDefaultPolicyVersionRequest {
    
    const filterSensitiveLog: (obj: SetDefaultPolicyVersionRequest) => any;
}
export declare enum GlobalEndpointTokenVersion {
    v1Token = "v1Token",
    v2Token = "v2Token"
}
export interface SetSecurityTokenServicePreferencesRequest {
    
    GlobalEndpointTokenVersion: GlobalEndpointTokenVersion | string | undefined;
}
export declare namespace SetSecurityTokenServicePreferencesRequest {
    
    const filterSensitiveLog: (obj: SetSecurityTokenServicePreferencesRequest) => any;
}

export declare class PolicyEvaluationException extends __BaseException {
    readonly name: "PolicyEvaluationException";
    readonly $fault: "server";
    
    constructor(opts: __ExceptionOptionType<PolicyEvaluationException, __BaseException>);
}
export declare enum 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"
}

export interface ContextEntry {
    
    ContextKeyName?: string;
    
    ContextKeyValues?: string[];
    
    ContextKeyType?: ContextKeyTypeEnum | string;
}
export declare namespace ContextEntry {
    
    const filterSensitiveLog: (obj: ContextEntry) => any;
}
export interface SimulateCustomPolicyRequest {
    
    PolicyInputList: string[] | undefined;
    
    PermissionsBoundaryPolicyInputList?: string[];
    
    ActionNames: string[] | undefined;
    
    ResourceArns?: string[];
    
    ResourcePolicy?: string;
    
    ResourceOwner?: string;
    
    CallerArn?: string;
    
    ContextEntries?: ContextEntry[];
    
    ResourceHandlingOption?: string;
    
    MaxItems?: number;
    
    Marker?: string;
}
export declare namespace SimulateCustomPolicyRequest {
    
    const filterSensitiveLog: (obj: SimulateCustomPolicyRequest) => any;
}
export declare enum PolicyEvaluationDecisionType {
    ALLOWED = "allowed",
    EXPLICIT_DENY = "explicitDeny",
    IMPLICIT_DENY = "implicitDeny"
}

export interface Position {
    
    Line?: number;
    
    Column?: number;
}
export declare namespace Position {
    
    const filterSensitiveLog: (obj: Position) => any;
}
export declare enum PolicySourceType {
    AWS_MANAGED = "aws-managed",
    GROUP = "group",
    NONE = "none",
    RESOURCE = "resource",
    ROLE = "role",
    USER = "user",
    USER_MANAGED = "user-managed"
}

export interface Statement {
    
    SourcePolicyId?: string;
    
    SourcePolicyType?: PolicySourceType | string;
    
    StartPosition?: Position;
    
    EndPosition?: Position;
}
export declare namespace Statement {
    
    const filterSensitiveLog: (obj: Statement) => any;
}

export interface OrganizationsDecisionDetail {
    
    AllowedByOrganizations?: boolean;
}
export declare namespace OrganizationsDecisionDetail {
    
    const filterSensitiveLog: (obj: OrganizationsDecisionDetail) => any;
}

export interface PermissionsBoundaryDecisionDetail {
    
    AllowedByPermissionsBoundary?: boolean;
}
export declare namespace PermissionsBoundaryDecisionDetail {
    
    const filterSensitiveLog: (obj: PermissionsBoundaryDecisionDetail) => any;
}

export interface ResourceSpecificResult {
    
    EvalResourceName: string | undefined;
    
    EvalResourceDecision: PolicyEvaluationDecisionType | string | undefined;
    
    MatchedStatements?: Statement[];
    
    MissingContextValues?: string[];
    
    EvalDecisionDetails?: {
        [key: string]: PolicyEvaluationDecisionType | string;
    };
    
    PermissionsBoundaryDecisionDetail?: PermissionsBoundaryDecisionDetail;
}
export declare namespace ResourceSpecificResult {
    
    const filterSensitiveLog: (obj: ResourceSpecificResult) => any;
}

export interface EvaluationResult {
    
    EvalActionName: string | undefined;
    
    EvalResourceName?: string;
    
    EvalDecision: PolicyEvaluationDecisionType | string | undefined;
    
    MatchedStatements?: Statement[];
    
    MissingContextValues?: string[];
    
    OrganizationsDecisionDetail?: OrganizationsDecisionDetail;
    
    PermissionsBoundaryDecisionDetail?: PermissionsBoundaryDecisionDetail;
    
    EvalDecisionDetails?: {
        [key: string]: PolicyEvaluationDecisionType | string;
    };
    
    ResourceSpecificResults?: ResourceSpecificResult[];
}
export declare namespace EvaluationResult {
    
    const filterSensitiveLog: (obj: EvaluationResult) => any;
}

export interface SimulatePolicyResponse {
    
    EvaluationResults?: EvaluationResult[];
    
    IsTruncated?: boolean;
    
    Marker?: string;
}
export declare namespace SimulatePolicyResponse {
    
    const filterSensitiveLog: (obj: SimulatePolicyResponse) => any;
}
export interface SimulatePrincipalPolicyRequest {
    
    PolicySourceArn: string | undefined;
    
    PolicyInputList?: string[];
    
    PermissionsBoundaryPolicyInputList?: string[];
    
    ActionNames: string[] | undefined;
    
    ResourceArns?: string[];
    
    ResourcePolicy?: string;
    
    ResourceOwner?: string;
    
    CallerArn?: string;
    
    ContextEntries?: ContextEntry[];
    
    ResourceHandlingOption?: string;
    
    MaxItems?: number;
    
    Marker?: string;
}
export declare namespace SimulatePrincipalPolicyRequest {
    
    const filterSensitiveLog: (obj: SimulatePrincipalPolicyRequest) => any;
}
export interface TagInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: TagInstanceProfileRequest) => any;
}
export interface TagMFADeviceRequest {
    
    SerialNumber: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagMFADeviceRequest {
    
    const filterSensitiveLog: (obj: TagMFADeviceRequest) => any;
}
export interface TagOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: TagOpenIDConnectProviderRequest) => any;
}
export interface TagPolicyRequest {
    
    PolicyArn: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagPolicyRequest {
    
    const filterSensitiveLog: (obj: TagPolicyRequest) => any;
}
export interface TagRoleRequest {
    
    RoleName: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagRoleRequest {
    
    const filterSensitiveLog: (obj: TagRoleRequest) => any;
}
export interface TagSAMLProviderRequest {
    
    SAMLProviderArn: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagSAMLProviderRequest {
    
    const filterSensitiveLog: (obj: TagSAMLProviderRequest) => any;
}
export interface TagServerCertificateRequest {
    
    ServerCertificateName: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagServerCertificateRequest {
    
    const filterSensitiveLog: (obj: TagServerCertificateRequest) => any;
}
export interface TagUserRequest {
    
    UserName: string | undefined;
    
    Tags: Tag[] | undefined;
}
export declare namespace TagUserRequest {
    
    const filterSensitiveLog: (obj: TagUserRequest) => any;
}
export interface UntagInstanceProfileRequest {
    
    InstanceProfileName: string | undefined;
    
    TagKeys: string[] | undefined;
}
export declare namespace UntagInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: UntagInstanceProfileRequest) => any;
}
export interface UntagMFADeviceRequest {
    
    SerialNumber: string | undefined;
    
    TagKeys: string[] | undefined;
}
export declare namespace UntagMFADeviceRequest {
    
    const filterSensitiveLog: (obj: UntagMFADeviceRequest) => any;
}
export interface UntagOpenIDConnectProviderRequest {
    
    OpenIDConnectProviderArn: string | undefined;
    
    TagKeys: string[] | undefined;
}
export declare namespace UntagOpenIDConnectProviderRequest {
    
    const filterSensitiveLog: (obj: UntagOpenIDConnectProviderRequest) => any;
}
