export interface IAMUser {
    UserName: string;
    UserId: string;
    Arn: string;
    Path?: string;
    CreateDate?: string;
    PasswordLastUsed?: string;
    PermissionsBoundary?: {
        PermissionsBoundaryType: string;
        PermissionsBoundaryArn: string;
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface CreateUserParams {
    UserName: string;
    Path?: string;
    PermissionsBoundary?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface GetUserParams {
    UserName?: string;
}
export interface ListUsersParams {
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface UpdateUserParams {
    UserName: string;
    NewUserName?: string;
    NewPath?: string;
}
export interface DeleteUserParams {
    UserName: string;
}
export interface IAMGroup {
    GroupName: string;
    GroupId: string;
    Arn: string;
    Path?: string;
    CreateDate?: string;
}
export interface CreateGroupParams {
    GroupName: string;
    Path?: string;
}
export interface GetGroupParams {
    GroupName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface ListGroupsParams {
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface UpdateGroupParams {
    GroupName: string;
    NewGroupName?: string;
    NewPath?: string;
}
export interface DeleteGroupParams {
    GroupName: string;
}
export interface AddUserToGroupParams {
    GroupName: string;
    UserName: string;
}
export interface RemoveUserFromGroupParams {
    GroupName: string;
    UserName: string;
}
export interface ListGroupsForUserParams {
    UserName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface IAMRole {
    RoleName: string;
    RoleId: string;
    Arn: string;
    Path?: string;
    CreateDate?: string;
    AssumeRolePolicyDocument?: string;
    Description?: string;
    MaxSessionDuration?: number;
    PermissionsBoundary?: {
        PermissionsBoundaryType: string;
        PermissionsBoundaryArn: string;
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
    RoleLastUsed?: {
        LastUsedDate?: string;
        Region?: string;
    };
}
export interface CreateRoleParams {
    RoleName: string;
    AssumeRolePolicyDocument: string;
    Path?: string;
    Description?: string;
    MaxSessionDuration?: number;
    PermissionsBoundary?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface GetRoleParams {
    RoleName: string;
}
export interface ListRolesParams {
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface UpdateRoleParams {
    RoleName: string;
    Description?: string;
    MaxSessionDuration?: number;
}
export interface UpdateRoleDescriptionParams {
    RoleName: string;
    Description: string;
}
export interface UpdateAssumeRolePolicyParams {
    RoleName: string;
    PolicyDocument: string;
}
export interface DeleteRoleParams {
    RoleName: string;
}
export interface TagRoleParams {
    RoleName: string;
    Tags: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface UntagRoleParams {
    RoleName: string;
    TagKeys: string[];
}
export interface ListRoleTagsParams {
    RoleName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface IAMPolicy {
    PolicyName: string;
    PolicyId: string;
    Arn: string;
    Path?: string;
    DefaultVersionId?: string;
    AttachmentCount?: number;
    PermissionsBoundaryUsageCount?: number;
    IsAttachable?: boolean;
    Description?: string;
    CreateDate?: string;
    UpdateDate?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface PolicyVersion {
    VersionId: string;
    IsDefaultVersion: boolean;
    CreateDate?: string;
    Document?: string;
}
export interface CreatePolicyParams {
    PolicyName: string;
    PolicyDocument: string;
    Path?: string;
    Description?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface GetPolicyParams {
    PolicyArn: string;
}
export interface GetPolicyVersionParams {
    PolicyArn: string;
    VersionId: string;
}
export interface ListPoliciesParams {
    Scope?: 'All' | 'AWS' | 'Local';
    OnlyAttached?: boolean;
    PathPrefix?: string;
    PolicyUsageFilter?: 'PermissionsPolicy' | 'PermissionsBoundary';
    Marker?: string;
    MaxItems?: number;
}
export interface ListPolicyVersionsParams {
    PolicyArn: string;
    Marker?: string;
    MaxItems?: number;
}
export interface CreatePolicyVersionParams {
    PolicyArn: string;
    PolicyDocument: string;
    SetAsDefault?: boolean;
}
export interface DeletePolicyVersionParams {
    PolicyArn: string;
    VersionId: string;
}
export interface SetDefaultPolicyVersionParams {
    PolicyArn: string;
    VersionId: string;
}
export interface DeletePolicyParams {
    PolicyArn: string;
}
export interface AttachUserPolicyParams {
    UserName: string;
    PolicyArn: string;
}
export interface DetachUserPolicyParams {
    UserName: string;
    PolicyArn: string;
}
export interface AttachGroupPolicyParams {
    GroupName: string;
    PolicyArn: string;
}
export interface DetachGroupPolicyParams {
    GroupName: string;
    PolicyArn: string;
}
export interface AttachRolePolicyParams {
    RoleName: string;
    PolicyArn: string;
}
export interface DetachRolePolicyParams {
    RoleName: string;
    PolicyArn: string;
}
export interface ListAttachedUserPoliciesParams {
    UserName: string;
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface ListAttachedGroupPoliciesParams {
    GroupName: string;
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface ListAttachedRolePoliciesParams {
    RoleName: string;
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface ListEntitiesForPolicyParams {
    PolicyArn: string;
    EntityFilter?: 'User' | 'Role' | 'Group' | 'LocalManagedPolicy' | 'AWSManagedPolicy';
    PathPrefix?: string;
    PolicyUsageFilter?: 'PermissionsPolicy' | 'PermissionsBoundary';
    Marker?: string;
    MaxItems?: number;
}
export interface PutUserPolicyParams {
    UserName: string;
    PolicyName: string;
    PolicyDocument: string;
}
export interface GetUserPolicyParams {
    UserName: string;
    PolicyName: string;
}
export interface DeleteUserPolicyParams {
    UserName: string;
    PolicyName: string;
}
export interface ListUserPoliciesParams {
    UserName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface PutGroupPolicyParams {
    GroupName: string;
    PolicyName: string;
    PolicyDocument: string;
}
export interface GetGroupPolicyParams {
    GroupName: string;
    PolicyName: string;
}
export interface DeleteGroupPolicyParams {
    GroupName: string;
    PolicyName: string;
}
export interface ListGroupPoliciesParams {
    GroupName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface PutRolePolicyParams {
    RoleName: string;
    PolicyName: string;
    PolicyDocument: string;
}
export interface GetRolePolicyParams {
    RoleName: string;
    PolicyName: string;
}
export interface DeleteRolePolicyParams {
    RoleName: string;
    PolicyName: string;
}
export interface ListRolePoliciesParams {
    RoleName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface AccessKey {
    UserName: string;
    AccessKeyId: string;
    Status: 'Active' | 'Inactive';
    CreateDate?: string;
}
export interface AccessKeyMetadata {
    UserName?: string;
    AccessKeyId: string;
    Status: 'Active' | 'Inactive';
    CreateDate?: string;
}
export interface CreateAccessKeyParams {
    UserName?: string;
}
export interface CreateAccessKeyResult {
    AccessKey: {
        UserName: string;
        AccessKeyId: string;
        Status: 'Active' | 'Inactive';
        SecretAccessKey: string;
        CreateDate?: string;
    };
}
export interface ListAccessKeysParams {
    UserName?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface UpdateAccessKeyParams {
    UserName?: string;
    AccessKeyId: string;
    Status: 'Active' | 'Inactive';
}
export interface DeleteAccessKeyParams {
    UserName?: string;
    AccessKeyId: string;
}
export interface GetAccessKeyLastUsedParams {
    AccessKeyId: string;
}
export interface InstanceProfile {
    InstanceProfileName: string;
    InstanceProfileId: string;
    Arn: string;
    Path?: string;
    CreateDate?: string;
    Roles?: IAMRole[];
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface CreateInstanceProfileParams {
    InstanceProfileName: string;
    Path?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface GetInstanceProfileParams {
    InstanceProfileName: string;
}
export interface ListInstanceProfilesParams {
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface ListInstanceProfilesForRoleParams {
    RoleName: string;
    Marker?: string;
    MaxItems?: number;
}
export interface AddRoleToInstanceProfileParams {
    InstanceProfileName: string;
    RoleName: string;
}
export interface RemoveRoleFromInstanceProfileParams {
    InstanceProfileName: string;
    RoleName: string;
}
export interface DeleteInstanceProfileParams {
    InstanceProfileName: string;
}
export interface ServerCertificate {
    ServerCertificateName: string;
    ServerCertificateId: string;
    Arn: string;
    Path?: string;
    UploadDate?: string;
    Expiration?: string;
}
export interface ServerCertificateMetadata {
    ServerCertificateName: string;
    ServerCertificateId: string;
    Arn: string;
    Path?: string;
    UploadDate?: string;
    Expiration?: string;
}
export interface UploadServerCertificateParams {
    ServerCertificateName: string;
    CertificateBody: string;
    PrivateKey: string;
    CertificateChain?: string;
    Path?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface GetServerCertificateParams {
    ServerCertificateName: string;
}
export interface ListServerCertificatesParams {
    PathPrefix?: string;
    Marker?: string;
    MaxItems?: number;
}
export interface UpdateServerCertificateParams {
    ServerCertificateName: string;
    NewServerCertificateName?: string;
    NewPath?: string;
}
export interface DeleteServerCertificateParams {
    ServerCertificateName: string;
}
export interface PasswordPolicy {
    MinimumPasswordLength?: number;
    RequireSymbols?: boolean;
    RequireNumbers?: boolean;
    RequireUppercaseCharacters?: boolean;
    RequireLowercaseCharacters?: boolean;
    AllowUsersToChangePassword?: boolean;
    ExpirePasswords?: boolean;
    MaxPasswordAge?: number;
    PasswordReusePrevention?: number;
    HardExpiry?: boolean;
}
export interface UpdateAccountPasswordPolicyParams {
    MinimumPasswordLength?: number;
    RequireSymbols?: boolean;
    RequireNumbers?: boolean;
    RequireUppercaseCharacters?: boolean;
    RequireLowercaseCharacters?: boolean;
    AllowUsersToChangePassword?: boolean;
    MaxPasswordAge?: number;
    PasswordReusePrevention?: number;
    HardExpiry?: boolean;
}
export interface AccountSummary {
    Users?: number;
    UsersQuota?: number;
    Groups?: number;
    GroupsQuota?: number;
    ServerCertificates?: number;
    ServerCertificatesQuota?: number;
    UserPolicySizeQuota?: number;
    GroupPolicySizeQuota?: number;
    GroupsPerUserQuota?: number;
    SigningCertificatesPerUserQuota?: number;
    AccessKeysPerUserQuota?: number;
    MFADevices?: number;
    MFADevicesInUse?: number;
    AccountMFAEnabled?: number;
    AccountAccessKeysPresent?: number;
    AccountSigningCertificatesPresent?: number;
    AttachedPoliciesPerGroupQuota?: number;
    AttachedPoliciesPerRoleQuota?: number;
    AttachedPoliciesPerUserQuota?: number;
    Policies?: number;
    PoliciesQuota?: number;
    PolicySizeQuota?: number;
    PolicyVersionsInUse?: number;
    PolicyVersionsInUseQuota?: number;
    VersionsPerPolicyQuota?: number;
    GlobalEndpointTokenVersion?: number;
}
export interface SimulatePrincipalPolicyParams {
    PolicySourceArn: string;
    ActionNames: string[];
    ResourceArns?: string[];
    ResourcePolicy?: string;
    ResourceOwner?: string;
    CallerArn?: string;
    ContextEntries?: Array<{
        ContextKeyName: string;
        ContextKeyValues: string[];
        ContextKeyType: string;
    }>;
    ResourceHandlingOption?: string;
    MaxItems?: number;
    Marker?: string;
}
export interface EvaluationResult {
    EvalActionName: string;
    EvalResourceName?: string;
    EvalDecision: string;
    MatchedStatements?: Array<{
        SourcePolicyId?: string;
        SourcePolicyType?: string;
    }>;
    MissingContextValues?: string[];
}
export interface SimulatePolicyResponse {
    EvaluationResults: EvaluationResult[];
    IsTruncated: boolean;
    Marker?: string;
}
export declare class IAMClient {
    private client;
    private region;
    constructor(region?: string, profile?: string);
    /**
     * Make IAM API request
     */
    private request;
    /**
     * Create a new IAM user
     */
    createUser(params: CreateUserParams): Promise<IAMUser>;
    /**
     * Get information about an IAM user
     */
    getUser(params?: GetUserParams): Promise<IAMUser>;
    /**
     * List IAM users
     */
    listUsers(params?: ListUsersParams): Promise<{
        Users: IAMUser[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Update an IAM user
     */
    updateUser(params: UpdateUserParams): Promise<void>;
    /**
     * Delete an IAM user
     */
    deleteUser(params: DeleteUserParams): Promise<void>;
    /**
     * Parse user from XML response
     */
    private parseUser;
    /**
     * Parse users array from XML response
     */
    private parseUsers;
    /**
     * Create a new IAM group
     */
    createGroup(params: CreateGroupParams): Promise<IAMGroup>;
    /**
     * Get information about an IAM group
     */
    getGroup(params: GetGroupParams): Promise<{
        Group: IAMGroup;
        Users: IAMUser[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * List IAM groups
     */
    listGroups(params?: ListGroupsParams): Promise<{
        Groups: IAMGroup[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Update an IAM group
     */
    updateGroup(params: UpdateGroupParams): Promise<void>;
    /**
     * Delete an IAM group
     */
    deleteGroup(params: DeleteGroupParams): Promise<void>;
    /**
     * Add a user to a group
     */
    addUserToGroup(params: AddUserToGroupParams): Promise<void>;
    /**
     * Remove a user from a group
     */
    removeUserFromGroup(params: RemoveUserFromGroupParams): Promise<void>;
    /**
     * List groups for a user
     */
    listGroupsForUser(params: ListGroupsForUserParams): Promise<{
        Groups: IAMGroup[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Parse group from XML response
     */
    private parseGroup;
    /**
     * Parse groups array from XML response
     */
    private parseGroups;
    /**
     * Create a new IAM role
     */
    createRole(params: CreateRoleParams): Promise<IAMRole>;
    /**
     * Get information about an IAM role
     */
    getRole(params: GetRoleParams): Promise<IAMRole>;
    /**
     * List IAM roles
     */
    listRoles(params?: ListRolesParams): Promise<{
        Roles: IAMRole[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Update an IAM role
     */
    updateRole(params: UpdateRoleParams): Promise<void>;
    /**
     * Update an IAM role description
     */
    updateRoleDescription(params: UpdateRoleDescriptionParams): Promise<IAMRole>;
    /**
     * Update the assume role policy for a role
     */
    updateAssumeRolePolicy(params: UpdateAssumeRolePolicyParams): Promise<void>;
    /**
     * Delete an IAM role
     */
    deleteRole(params: DeleteRoleParams): Promise<void>;
    /**
     * Tag an IAM role
     */
    tagRole(params: TagRoleParams): Promise<void>;
    /**
     * Untag an IAM role
     */
    untagRole(params: UntagRoleParams): Promise<void>;
    /**
     * List tags for an IAM role
     */
    listRoleTags(params: ListRoleTagsParams): Promise<{
        Tags: Array<{
            Key: string;
            Value: string;
        }>;
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Parse role from XML response
     */
    private parseRole;
    /**
     * Parse roles array from XML response
     */
    private parseRoles;
    /**
     * Parse tags from XML response
     */
    private parseTags;
    /**
     * Create a new managed policy
     */
    createPolicy(params: CreatePolicyParams): Promise<IAMPolicy>;
    /**
     * Get information about a managed policy
     */
    getPolicy(params: GetPolicyParams): Promise<IAMPolicy>;
    /**
     * Get a specific version of a managed policy
     */
    getPolicyVersion(params: GetPolicyVersionParams): Promise<PolicyVersion>;
    /**
     * List managed policies
     */
    listPolicies(params?: ListPoliciesParams): Promise<{
        Policies: IAMPolicy[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * List versions of a managed policy
     */
    listPolicyVersions(params: ListPolicyVersionsParams): Promise<{
        Versions: PolicyVersion[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Create a new version of a managed policy
     */
    createPolicyVersion(params: CreatePolicyVersionParams): Promise<PolicyVersion>;
    /**
     * Delete a version of a managed policy
     */
    deletePolicyVersion(params: DeletePolicyVersionParams): Promise<void>;
    /**
     * Set the default version of a managed policy
     */
    setDefaultPolicyVersion(params: SetDefaultPolicyVersionParams): Promise<void>;
    /**
     * Delete a managed policy
     */
    deletePolicy(params: DeletePolicyParams): Promise<void>;
    /**
     * Attach a managed policy to a user
     */
    attachUserPolicy(params: AttachUserPolicyParams): Promise<void>;
    /**
     * Detach a managed policy from a user
     */
    detachUserPolicy(params: DetachUserPolicyParams): Promise<void>;
    /**
     * Attach a managed policy to a group
     */
    attachGroupPolicy(params: AttachGroupPolicyParams): Promise<void>;
    /**
     * Detach a managed policy from a group
     */
    detachGroupPolicy(params: DetachGroupPolicyParams): Promise<void>;
    /**
     * Attach a managed policy to a role
     */
    attachRolePolicy(params: AttachRolePolicyParams): Promise<void>;
    /**
     * Detach a managed policy from a role
     */
    detachRolePolicy(params: DetachRolePolicyParams): Promise<void>;
    /**
     * List managed policies attached to a user
     */
    listAttachedUserPolicies(params: ListAttachedUserPoliciesParams): Promise<{
        AttachedPolicies: Array<{
            PolicyName: string;
            PolicyArn: string;
        }>;
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * List managed policies attached to a group
     */
    listAttachedGroupPolicies(params: ListAttachedGroupPoliciesParams): Promise<{
        AttachedPolicies: Array<{
            PolicyName: string;
            PolicyArn: string;
        }>;
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * List managed policies attached to a role
     */
    listAttachedRolePolicies(params: ListAttachedRolePoliciesParams): Promise<{
        AttachedPolicies: Array<{
            PolicyName: string;
            PolicyArn: string;
        }>;
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Parse policy from XML response
     */
    private parsePolicy;
    /**
     * Parse policies array from XML response
     */
    private parsePolicies;
    /**
     * Parse policy versions from XML response
     */
    private parsePolicyVersions;
    /**
     * Parse attached policies from XML response
     */
    private parseAttachedPolicies;
    /**
     * Add or update an inline policy for a user
     */
    putUserPolicy(params: PutUserPolicyParams): Promise<void>;
    /**
     * Get an inline policy for a user
     */
    getUserPolicy(params: GetUserPolicyParams): Promise<{
        UserName: string;
        PolicyName: string;
        PolicyDocument: string;
    }>;
    /**
     * Delete an inline policy from a user
     */
    deleteUserPolicy(params: DeleteUserPolicyParams): Promise<void>;
    /**
     * List inline policies for a user
     */
    listUserPolicies(params: ListUserPoliciesParams): Promise<{
        PolicyNames: string[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Add or update an inline policy for a group
     */
    putGroupPolicy(params: PutGroupPolicyParams): Promise<void>;
    /**
     * Get an inline policy for a group
     */
    getGroupPolicy(params: GetGroupPolicyParams): Promise<{
        GroupName: string;
        PolicyName: string;
        PolicyDocument: string;
    }>;
    /**
     * Delete an inline policy from a group
     */
    deleteGroupPolicy(params: DeleteGroupPolicyParams): Promise<void>;
    /**
     * List inline policies for a group
     */
    listGroupPolicies(params: ListGroupPoliciesParams): Promise<{
        PolicyNames: string[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Add or update an inline policy for a role
     */
    putRolePolicy(params: PutRolePolicyParams): Promise<void>;
    /**
     * Get an inline policy for a role
     */
    getRolePolicy(params: GetRolePolicyParams): Promise<{
        RoleName: string;
        PolicyName: string;
        PolicyDocument: string;
    }>;
    /**
     * Delete an inline policy from a role
     */
    deleteRolePolicy(params: DeleteRolePolicyParams): Promise<void>;
    /**
     * List inline policies for a role
     */
    listRolePolicies(params: ListRolePoliciesParams): Promise<{
        PolicyNames: string[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Create an access key for a user
     */
    createAccessKey(params?: CreateAccessKeyParams): Promise<CreateAccessKeyResult>;
    /**
     * List access keys for a user
     */
    listAccessKeys(params?: ListAccessKeysParams): Promise<{
        AccessKeyMetadata: AccessKeyMetadata[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Update an access key status
     */
    updateAccessKey(params: UpdateAccessKeyParams): Promise<void>;
    /**
     * Delete an access key
     */
    deleteAccessKey(params: DeleteAccessKeyParams): Promise<void>;
    /**
     * Get information about when an access key was last used
     */
    getAccessKeyLastUsed(params: GetAccessKeyLastUsedParams): Promise<{
        UserName: string;
        AccessKeyLastUsed: {
            LastUsedDate?: string;
            ServiceName?: string;
            Region?: string;
        };
    }>;
    /**
     * Parse access keys from XML response
     */
    private parseAccessKeys;
    /**
     * Create an instance profile
     */
    createInstanceProfile(params: CreateInstanceProfileParams): Promise<InstanceProfile>;
    /**
     * Get information about an instance profile
     */
    getInstanceProfile(params: GetInstanceProfileParams): Promise<InstanceProfile>;
    /**
     * List instance profiles
     */
    listInstanceProfiles(params?: ListInstanceProfilesParams): Promise<{
        InstanceProfiles: InstanceProfile[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * List instance profiles for a role
     */
    listInstanceProfilesForRole(params: ListInstanceProfilesForRoleParams): Promise<{
        InstanceProfiles: InstanceProfile[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Add a role to an instance profile
     */
    addRoleToInstanceProfile(params: AddRoleToInstanceProfileParams): Promise<void>;
    /**
     * Remove a role from an instance profile
     */
    removeRoleFromInstanceProfile(params: RemoveRoleFromInstanceProfileParams): Promise<void>;
    /**
     * Delete an instance profile
     */
    deleteInstanceProfile(params: DeleteInstanceProfileParams): Promise<void>;
    /**
     * Parse instance profile from XML response
     */
    private parseInstanceProfile;
    /**
     * Parse instance profiles from XML response
     */
    private parseInstanceProfiles;
    /**
     * Get account password policy
     */
    getAccountPasswordPolicy(): Promise<PasswordPolicy>;
    /**
     * Update account password policy
     */
    updateAccountPasswordPolicy(params: UpdateAccountPasswordPolicyParams): Promise<void>;
    /**
     * Delete account password policy
     */
    deleteAccountPasswordPolicy(): Promise<void>;
    /**
     * Get account summary
     */
    getAccountSummary(): Promise<AccountSummary>;
    /**
     * Get the account alias
     */
    listAccountAliases(): Promise<{
        AccountAliases: string[];
        IsTruncated: boolean;
        Marker?: string;
    }>;
    /**
     * Create an account alias
     */
    createAccountAlias(params: {
        AccountAlias: string;
    }): Promise<void>;
    /**
     * Delete an account alias
     */
    deleteAccountAlias(params: {
        AccountAlias: string;
    }): Promise<void>;
    /**
     * Simulate the effect of policies attached to a principal
     */
    simulatePrincipalPolicy(params: SimulatePrincipalPolicyParams): Promise<SimulatePolicyResponse>;
    /**
     * Parse simulation results from XML response
     */
    private parseSimulationResults;
}
