iam

Documentation

Index

• Constants
• type Iam
  • func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Iam
  • func New(p client.ConfigProvider, cfgs ...*aws.Config) *Iam
  • func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Iam
  • func (c *Iam) AccountListRoles(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AccountListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AccountListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) AddProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AddProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AddProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) AddUserToGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AddUserToGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AddUserToGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) AttachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AttachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AttachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) AttachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AttachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AttachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) AttachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) AttachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) AttachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) BatchGetInstanceProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) BatchGetInstanceProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) BatchGetInstanceProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) BatchGetProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) BatchGetProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) BatchGetProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ChangePassword(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ChangePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ChangePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CheckUserEnableMFA(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CheckUserEnableMFARequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CheckUserEnableMFAWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CheckUserSessionCode(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CheckUserSessionCodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CheckUserSessionCodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateAccount(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateAccountRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateAccountWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreatePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreatePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreatePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateProject(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateUser(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) CreateVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) CreateVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) CreateVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeactivateAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeactivateAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeactivateAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeactivateMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeactivateMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeactivateMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteIdentityAndProjectRelation(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteIdentityAndProjectRelationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteIdentityAndProjectRelationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeletePolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeletePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeletePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeletePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeletePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeletePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteUser(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DeleteVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DeleteVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DeleteVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DetachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DetachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DetachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DetachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DetachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DetachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) DetachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) DetachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) DetachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) EnableAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) EnableAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) EnableAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) EnableMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) EnableMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) EnableMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) EnableMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) EnableMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) EnableMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountAllProjectList(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountAllProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetAccountAllProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetAccountProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectList(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetAccountProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectTotal(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountProjectTotalRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetAccountProjectTotalWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountSummary(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetAccountSummaryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetAccountSummaryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetProjectInstanceList(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetProjectInstanceListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetProjectInstanceListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetPwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetPwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetPwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetUser(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetUserLoginInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetUserLoginInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetUserLoginInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetUserSession(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetUserSessionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetUserSessionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) GetVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) GetVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) GetVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListAccessKeys(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListAccessKeysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListAccessKeysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListApiLogTpl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListApiLogTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListApiLogTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListAttachedRolePolicies(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListAttachedRolePoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListAttachedRolePoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListAttachedUserPolicies(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListAttachedUserPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListAttachedUserPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListEntitiesForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListEntitiesForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListEntitiesForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListEntityForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListEntityForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListEntityForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListGroupPolicies(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListGroupPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListGroupPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListGroups(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListGroupsForUser(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListGroupsForUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListGroupsForUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListPolicies(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListPolicyVersions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListPolicyVersionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListPolicyVersionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListResourceKrn(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListResourceKrnRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListResourceKrnWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListRoles(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListServicePerm(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListServicePermRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListServicePermWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListServiceRolesTpl(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListServiceRolesTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListServiceRolesTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListServicesAndActions(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListServicesAndActionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListServicesAndActionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListUsers(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListUsersByIds(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListUsersByIdsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListUsersByIdsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListUsersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListUsersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ListVirtualMFADevices(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ListVirtualMFADevicesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ListVirtualMFADevicesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) RemoveUserFromGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) RemoveUserFromGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) RemoveUserFromGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) SetDefaultPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) SetDefaultPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) SetDefaultPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) SetMemberViewAllProject(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) SetMemberViewAllProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) SetMemberViewAllProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) SyncMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) SyncMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) SyncMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) Test(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) TestRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) TestWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateGroup(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateInstanceProjectId(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateInstanceProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateInstanceProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateProjectStatus(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateProjectStatusRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateProjectStatusWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdatePwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdatePwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdatePwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateRole(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateRoleTrustAccounts(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateRoleTrustAccountsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateRoleTrustAccountsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateUser(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateUserContactInfo(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UpdateUserContactInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateUserContactInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UpdateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UpdateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) UserLogin(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) UserLoginRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) UserLoginWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ValidPolicyDocument(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ValidPolicyDocumentRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ValidPolicyDocumentWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) ValidProjectId(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) ValidProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) ValidProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) VerificateCompany(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) VerificateCompanyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) VerificateCompanyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) VerificatePerson(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) VerificatePersonRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) VerificatePersonWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)
  • func (c *Iam) VerifyMFACode(input *map[string]interface{}) (*map[string]interface{}, error)
  • func (c *Iam) VerifyMFACodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})
  • func (c *Iam) VerifyMFACodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

Constants

const (
	ServiceName = "iam"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "iam"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Types

type Iam

type Iam struct {
	*client.Client
}

Iam provides the API operation methods for making requests to iam. See this package's package overview docs for details on the service.

Iam methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Iam

extraNew create int can support ssl or region locate set

func New

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Iam

New creates a new instance of the Iam client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Iam client from just a session.
svc := iam.New(mySession)

// Create a Iam client with additional configuration
svc := iam.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Iam

SdkNew create int can support ssl or region locate set

func (*Iam) AccountListRoles

func (c *Iam) AccountListRoles(input *map[string]interface{}) (*map[string]interface{}, error)

AccountListRoles API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AccountListRoles for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AccountListRoles

func (*Iam) AccountListRolesRequest

func (c *Iam) AccountListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AccountListRolesRequest generates a "ksc/request.Request" representing the client's request for the AccountListRoles operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AccountListRoles for more information on using the AccountListRoles API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AccountListRolesRequest method.
req, resp := client.AccountListRolesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AccountListRoles

func (*Iam) AccountListRolesWithContext

func (c *Iam) AccountListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AccountListRolesWithContext is the same as AccountListRoles with the addition of the ability to pass a context and additional request options.

See AccountListRoles for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AddProjectMember

func (c *Iam) AddProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

AddProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AddProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddProjectMember

func (*Iam) AddProjectMemberRequest

func (c *Iam) AddProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the AddProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddProjectMember for more information on using the AddProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddProjectMemberRequest method.
req, resp := client.AddProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddProjectMember

func (*Iam) AddProjectMemberWithContext

func (c *Iam) AddProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddProjectMemberWithContext is the same as AddProjectMember with the addition of the ability to pass a context and additional request options.

See AddProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AddUserToGroup

func (c *Iam) AddUserToGroup(input *map[string]interface{}) (*map[string]interface{}, error)

AddUserToGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AddUserToGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddUserToGroup

func (*Iam) AddUserToGroupRequest

func (c *Iam) AddUserToGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddUserToGroupRequest generates a "ksc/request.Request" representing the client's request for the AddUserToGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddUserToGroup for more information on using the AddUserToGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddUserToGroupRequest method.
req, resp := client.AddUserToGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddUserToGroup

func (*Iam) AddUserToGroupWithContext

func (c *Iam) AddUserToGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddUserToGroupWithContext is the same as AddUserToGroup with the addition of the ability to pass a context and additional request options.

See AddUserToGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachGroupPolicy

func (c *Iam) AttachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachGroupPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachGroupPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachGroupPolicy

func (*Iam) AttachGroupPolicyRequest

func (c *Iam) AttachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachGroupPolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachGroupPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachGroupPolicy for more information on using the AttachGroupPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachGroupPolicyRequest method.
req, resp := client.AttachGroupPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachGroupPolicy

func (*Iam) AttachGroupPolicyWithContext

func (c *Iam) AttachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachGroupPolicyWithContext is the same as AttachGroupPolicy with the addition of the ability to pass a context and additional request options.

See AttachGroupPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachRolePolicy

func (c *Iam) AttachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachRolePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachRolePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachRolePolicy

func (*Iam) AttachRolePolicyRequest

func (c *Iam) AttachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachRolePolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachRolePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachRolePolicy for more information on using the AttachRolePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachRolePolicyRequest method.
req, resp := client.AttachRolePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachRolePolicy

func (*Iam) AttachRolePolicyWithContext

func (c *Iam) AttachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachRolePolicyWithContext is the same as AttachRolePolicy with the addition of the ability to pass a context and additional request options.

See AttachRolePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachUserPolicy

func (c *Iam) AttachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachUserPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachUserPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachUserPolicy

func (*Iam) AttachUserPolicyRequest

func (c *Iam) AttachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachUserPolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachUserPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachUserPolicy for more information on using the AttachUserPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachUserPolicyRequest method.
req, resp := client.AttachUserPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachUserPolicy

func (*Iam) AttachUserPolicyWithContext

func (c *Iam) AttachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachUserPolicyWithContext is the same as AttachUserPolicy with the addition of the ability to pass a context and additional request options.

See AttachUserPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) BatchGetInstanceProjectInfo

func (c *Iam) BatchGetInstanceProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

BatchGetInstanceProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation BatchGetInstanceProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetInstanceProjectInfo

func (*Iam) BatchGetInstanceProjectInfoRequest

func (c *Iam) BatchGetInstanceProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

BatchGetInstanceProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the BatchGetInstanceProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See BatchGetInstanceProjectInfo for more information on using the BatchGetInstanceProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the BatchGetInstanceProjectInfoRequest method.
req, resp := client.BatchGetInstanceProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetInstanceProjectInfo

func (*Iam) BatchGetInstanceProjectInfoWithContext

func (c *Iam) BatchGetInstanceProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

BatchGetInstanceProjectInfoWithContext is the same as BatchGetInstanceProjectInfo with the addition of the ability to pass a context and additional request options.

See BatchGetInstanceProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) BatchGetProjectInfo

func (c *Iam) BatchGetProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

BatchGetProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation BatchGetProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetProjectInfo

func (*Iam) BatchGetProjectInfoRequest

func (c *Iam) BatchGetProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

BatchGetProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the BatchGetProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See BatchGetProjectInfo for more information on using the BatchGetProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the BatchGetProjectInfoRequest method.
req, resp := client.BatchGetProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetProjectInfo

func (*Iam) BatchGetProjectInfoWithContext

func (c *Iam) BatchGetProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

BatchGetProjectInfoWithContext is the same as BatchGetProjectInfo with the addition of the ability to pass a context and additional request options.

See BatchGetProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ChangePassword

func (c *Iam) ChangePassword(input *map[string]interface{}) (*map[string]interface{}, error)

ChangePassword API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ChangePassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ChangePassword

func (*Iam) ChangePasswordRequest

func (c *Iam) ChangePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ChangePasswordRequest generates a "ksc/request.Request" representing the client's request for the ChangePassword operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ChangePassword for more information on using the ChangePassword API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ChangePasswordRequest method.
req, resp := client.ChangePasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ChangePassword

func (*Iam) ChangePasswordWithContext

func (c *Iam) ChangePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ChangePasswordWithContext is the same as ChangePassword with the addition of the ability to pass a context and additional request options.

See ChangePassword for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CheckUserEnableMFA

func (c *Iam) CheckUserEnableMFA(input *map[string]interface{}) (*map[string]interface{}, error)

CheckUserEnableMFA API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CheckUserEnableMFA for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserEnableMFA

func (*Iam) CheckUserEnableMFARequest

func (c *Iam) CheckUserEnableMFARequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CheckUserEnableMFARequest generates a "ksc/request.Request" representing the client's request for the CheckUserEnableMFA operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CheckUserEnableMFA for more information on using the CheckUserEnableMFA API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CheckUserEnableMFARequest method.
req, resp := client.CheckUserEnableMFARequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserEnableMFA

func (*Iam) CheckUserEnableMFAWithContext

func (c *Iam) CheckUserEnableMFAWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CheckUserEnableMFAWithContext is the same as CheckUserEnableMFA with the addition of the ability to pass a context and additional request options.

See CheckUserEnableMFA for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CheckUserSessionCode

func (c *Iam) CheckUserSessionCode(input *map[string]interface{}) (*map[string]interface{}, error)

CheckUserSessionCode API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CheckUserSessionCode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserSessionCode

func (*Iam) CheckUserSessionCodeRequest

func (c *Iam) CheckUserSessionCodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CheckUserSessionCodeRequest generates a "ksc/request.Request" representing the client's request for the CheckUserSessionCode operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CheckUserSessionCode for more information on using the CheckUserSessionCode API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CheckUserSessionCodeRequest method.
req, resp := client.CheckUserSessionCodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserSessionCode

func (*Iam) CheckUserSessionCodeWithContext

func (c *Iam) CheckUserSessionCodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CheckUserSessionCodeWithContext is the same as CheckUserSessionCode with the addition of the ability to pass a context and additional request options.

See CheckUserSessionCode for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateAccessKey

func (c *Iam) CreateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccessKey

func (*Iam) CreateAccessKeyRequest

func (c *Iam) CreateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the CreateAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateAccessKey for more information on using the CreateAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateAccessKeyRequest method.
req, resp := client.CreateAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccessKey

func (*Iam) CreateAccessKeyWithContext

func (c *Iam) CreateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateAccessKeyWithContext is the same as CreateAccessKey with the addition of the ability to pass a context and additional request options.

See CreateAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateAccount

func (c *Iam) CreateAccount(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAccount API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateAccount for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccount

func (*Iam) CreateAccountRequest

func (c *Iam) CreateAccountRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateAccountRequest generates a "ksc/request.Request" representing the client's request for the CreateAccount operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateAccount for more information on using the CreateAccount API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateAccountRequest method.
req, resp := client.CreateAccountRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccount

func (*Iam) CreateAccountWithContext

func (c *Iam) CreateAccountWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateAccountWithContext is the same as CreateAccount with the addition of the ability to pass a context and additional request options.

See CreateAccount for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateGroup

func (c *Iam) CreateGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateGroup

func (*Iam) CreateGroupRequest

func (c *Iam) CreateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateGroup for more information on using the CreateGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateGroupRequest method.
req, resp := client.CreateGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateGroup

func (*Iam) CreateGroupWithContext

func (c *Iam) CreateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateGroupWithContext is the same as CreateGroup with the addition of the ability to pass a context and additional request options.

See CreateGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateLoginProfile

func (c *Iam) CreateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateLoginProfile

func (*Iam) CreateLoginProfileRequest

func (c *Iam) CreateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the CreateLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLoginProfile for more information on using the CreateLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLoginProfileRequest method.
req, resp := client.CreateLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateLoginProfile

func (*Iam) CreateLoginProfileWithContext

func (c *Iam) CreateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLoginProfileWithContext is the same as CreateLoginProfile with the addition of the ability to pass a context and additional request options.

See CreateLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreatePolicy

func (c *Iam) CreatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreatePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicy

func (*Iam) CreatePolicyRequest

func (c *Iam) CreatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreatePolicyRequest generates a "ksc/request.Request" representing the client's request for the CreatePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreatePolicy for more information on using the CreatePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreatePolicyRequest method.
req, resp := client.CreatePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicy

func (*Iam) CreatePolicyVersion

func (c *Iam) CreatePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreatePolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicyVersion

func (*Iam) CreatePolicyVersionRequest

func (c *Iam) CreatePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreatePolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the CreatePolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreatePolicyVersion for more information on using the CreatePolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreatePolicyVersionRequest method.
req, resp := client.CreatePolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicyVersion

func (*Iam) CreatePolicyVersionWithContext

func (c *Iam) CreatePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreatePolicyVersionWithContext is the same as CreatePolicyVersion with the addition of the ability to pass a context and additional request options.

See CreatePolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreatePolicyWithContext

func (c *Iam) CreatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreatePolicyWithContext is the same as CreatePolicy with the addition of the ability to pass a context and additional request options.

See CreatePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateProject

func (c *Iam) CreateProject(input *map[string]interface{}) (*map[string]interface{}, error)

CreateProject API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateProject for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateProject

func (*Iam) CreateProjectRequest

func (c *Iam) CreateProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateProjectRequest generates a "ksc/request.Request" representing the client's request for the CreateProject operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateProject for more information on using the CreateProject API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateProjectRequest method.
req, resp := client.CreateProjectRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateProject

func (*Iam) CreateProjectWithContext

func (c *Iam) CreateProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateProjectWithContext is the same as CreateProject with the addition of the ability to pass a context and additional request options.

See CreateProject for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateRole

func (c *Iam) CreateRole(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateRole

func (*Iam) CreateRoleRequest

func (c *Iam) CreateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateRoleRequest generates a "ksc/request.Request" representing the client's request for the CreateRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateRole for more information on using the CreateRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateRoleRequest method.
req, resp := client.CreateRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateRole

func (*Iam) CreateRoleWithContext

func (c *Iam) CreateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateRoleWithContext is the same as CreateRole with the addition of the ability to pass a context and additional request options.

See CreateRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateUser

func (c *Iam) CreateUser(input *map[string]interface{}) (*map[string]interface{}, error)

CreateUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateUser

func (*Iam) CreateUserRequest

func (c *Iam) CreateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateUserRequest generates a "ksc/request.Request" representing the client's request for the CreateUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateUser for more information on using the CreateUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateUserRequest method.
req, resp := client.CreateUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateUser

func (*Iam) CreateUserWithContext

func (c *Iam) CreateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateUserWithContext is the same as CreateUser with the addition of the ability to pass a context and additional request options.

See CreateUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateVirtualMFADevice

func (c *Iam) CreateVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateVirtualMFADevice

func (*Iam) CreateVirtualMFADeviceRequest

func (c *Iam) CreateVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the CreateVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateVirtualMFADevice for more information on using the CreateVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateVirtualMFADeviceRequest method.
req, resp := client.CreateVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateVirtualMFADevice

func (*Iam) CreateVirtualMFADeviceWithContext

func (c *Iam) CreateVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateVirtualMFADeviceWithContext is the same as CreateVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See CreateVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeactivateAccountMFADevice

func (c *Iam) DeactivateAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeactivateAccountMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeactivateAccountMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateAccountMFADevice

func (*Iam) DeactivateAccountMFADeviceRequest

func (c *Iam) DeactivateAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeactivateAccountMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeactivateAccountMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeactivateAccountMFADevice for more information on using the DeactivateAccountMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeactivateAccountMFADeviceRequest method.
req, resp := client.DeactivateAccountMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateAccountMFADevice

func (*Iam) DeactivateAccountMFADeviceWithContext

func (c *Iam) DeactivateAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeactivateAccountMFADeviceWithContext is the same as DeactivateAccountMFADevice with the addition of the ability to pass a context and additional request options.

See DeactivateAccountMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeactivateMFADevice

func (c *Iam) DeactivateMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeactivateMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeactivateMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateMFADevice

func (*Iam) DeactivateMFADeviceRequest

func (c *Iam) DeactivateMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeactivateMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeactivateMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeactivateMFADevice for more information on using the DeactivateMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeactivateMFADeviceRequest method.
req, resp := client.DeactivateMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateMFADevice

func (*Iam) DeactivateMFADeviceWithContext

func (c *Iam) DeactivateMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeactivateMFADeviceWithContext is the same as DeactivateMFADevice with the addition of the ability to pass a context and additional request options.

See DeactivateMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteAccessKey

func (c *Iam) DeleteAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteAccessKey

func (*Iam) DeleteAccessKeyRequest

func (c *Iam) DeleteAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the DeleteAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteAccessKey for more information on using the DeleteAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteAccessKeyRequest method.
req, resp := client.DeleteAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteAccessKey

func (*Iam) DeleteAccessKeyWithContext

func (c *Iam) DeleteAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteAccessKeyWithContext is the same as DeleteAccessKey with the addition of the ability to pass a context and additional request options.

See DeleteAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteGroup

func (c *Iam) DeleteGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteGroup

func (*Iam) DeleteGroupRequest

func (c *Iam) DeleteGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteGroup for more information on using the DeleteGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteGroupRequest method.
req, resp := client.DeleteGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteGroup

func (*Iam) DeleteGroupWithContext

func (c *Iam) DeleteGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteGroupWithContext is the same as DeleteGroup with the addition of the ability to pass a context and additional request options.

See DeleteGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteIdentityAndProjectRelation

func (c *Iam) DeleteIdentityAndProjectRelation(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteIdentityAndProjectRelation API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteIdentityAndProjectRelation for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteIdentityAndProjectRelation

func (*Iam) DeleteIdentityAndProjectRelationRequest

func (c *Iam) DeleteIdentityAndProjectRelationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteIdentityAndProjectRelationRequest generates a "ksc/request.Request" representing the client's request for the DeleteIdentityAndProjectRelation operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteIdentityAndProjectRelation for more information on using the DeleteIdentityAndProjectRelation API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteIdentityAndProjectRelationRequest method.
req, resp := client.DeleteIdentityAndProjectRelationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteIdentityAndProjectRelation

func (*Iam) DeleteIdentityAndProjectRelationWithContext

func (c *Iam) DeleteIdentityAndProjectRelationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteIdentityAndProjectRelationWithContext is the same as DeleteIdentityAndProjectRelation with the addition of the ability to pass a context and additional request options.

See DeleteIdentityAndProjectRelation for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteLoginProfile

func (c *Iam) DeleteLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteLoginProfile

func (*Iam) DeleteLoginProfileRequest

func (c *Iam) DeleteLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the DeleteLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLoginProfile for more information on using the DeleteLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLoginProfileRequest method.
req, resp := client.DeleteLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteLoginProfile

func (*Iam) DeleteLoginProfileWithContext

func (c *Iam) DeleteLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLoginProfileWithContext is the same as DeleteLoginProfile with the addition of the ability to pass a context and additional request options.

See DeleteLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeletePolicy

func (c *Iam) DeletePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeletePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicy

func (*Iam) DeletePolicyRequest

func (c *Iam) DeletePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeletePolicyRequest generates a "ksc/request.Request" representing the client's request for the DeletePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeletePolicy for more information on using the DeletePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeletePolicyRequest method.
req, resp := client.DeletePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicy

func (*Iam) DeletePolicyVersion

func (c *Iam) DeletePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeletePolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicyVersion

func (*Iam) DeletePolicyVersionRequest

func (c *Iam) DeletePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeletePolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the DeletePolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeletePolicyVersion for more information on using the DeletePolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeletePolicyVersionRequest method.
req, resp := client.DeletePolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicyVersion

func (*Iam) DeletePolicyVersionWithContext

func (c *Iam) DeletePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeletePolicyVersionWithContext is the same as DeletePolicyVersion with the addition of the ability to pass a context and additional request options.

See DeletePolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeletePolicyWithContext

func (c *Iam) DeletePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeletePolicyWithContext is the same as DeletePolicy with the addition of the ability to pass a context and additional request options.

See DeletePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteProjectMember

func (c *Iam) DeleteProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteProjectMember

func (*Iam) DeleteProjectMemberRequest

func (c *Iam) DeleteProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the DeleteProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteProjectMember for more information on using the DeleteProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteProjectMemberRequest method.
req, resp := client.DeleteProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteProjectMember

func (*Iam) DeleteProjectMemberWithContext

func (c *Iam) DeleteProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteProjectMemberWithContext is the same as DeleteProjectMember with the addition of the ability to pass a context and additional request options.

See DeleteProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteRole

func (c *Iam) DeleteRole(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteRole

func (*Iam) DeleteRoleRequest

func (c *Iam) DeleteRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteRoleRequest generates a "ksc/request.Request" representing the client's request for the DeleteRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteRole for more information on using the DeleteRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteRoleRequest method.
req, resp := client.DeleteRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteRole

func (*Iam) DeleteRoleWithContext

func (c *Iam) DeleteRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteRoleWithContext is the same as DeleteRole with the addition of the ability to pass a context and additional request options.

See DeleteRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteUser

func (c *Iam) DeleteUser(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteUser

func (*Iam) DeleteUserRequest

func (c *Iam) DeleteUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteUserRequest generates a "ksc/request.Request" representing the client's request for the DeleteUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteUser for more information on using the DeleteUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteUserRequest method.
req, resp := client.DeleteUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteUser

func (*Iam) DeleteUserWithContext

func (c *Iam) DeleteUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteUserWithContext is the same as DeleteUser with the addition of the ability to pass a context and additional request options.

See DeleteUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteVirtualMFADevice

func (c *Iam) DeleteVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteVirtualMFADevice

func (*Iam) DeleteVirtualMFADeviceRequest

func (c *Iam) DeleteVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeleteVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteVirtualMFADevice for more information on using the DeleteVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteVirtualMFADeviceRequest method.
req, resp := client.DeleteVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteVirtualMFADevice

func (*Iam) DeleteVirtualMFADeviceWithContext

func (c *Iam) DeleteVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteVirtualMFADeviceWithContext is the same as DeleteVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See DeleteVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachGroupPolicy

func (c *Iam) DetachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachGroupPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachGroupPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachGroupPolicy

func (*Iam) DetachGroupPolicyRequest

func (c *Iam) DetachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachGroupPolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachGroupPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachGroupPolicy for more information on using the DetachGroupPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachGroupPolicyRequest method.
req, resp := client.DetachGroupPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachGroupPolicy

func (*Iam) DetachGroupPolicyWithContext

func (c *Iam) DetachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachGroupPolicyWithContext is the same as DetachGroupPolicy with the addition of the ability to pass a context and additional request options.

See DetachGroupPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachRolePolicy

func (c *Iam) DetachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachRolePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachRolePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachRolePolicy

func (*Iam) DetachRolePolicyRequest

func (c *Iam) DetachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachRolePolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachRolePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachRolePolicy for more information on using the DetachRolePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachRolePolicyRequest method.
req, resp := client.DetachRolePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachRolePolicy

func (*Iam) DetachRolePolicyWithContext

func (c *Iam) DetachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachRolePolicyWithContext is the same as DetachRolePolicy with the addition of the ability to pass a context and additional request options.

See DetachRolePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachUserPolicy

func (c *Iam) DetachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachUserPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachUserPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachUserPolicy

func (*Iam) DetachUserPolicyRequest

func (c *Iam) DetachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachUserPolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachUserPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachUserPolicy for more information on using the DetachUserPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachUserPolicyRequest method.
req, resp := client.DetachUserPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachUserPolicy

func (*Iam) DetachUserPolicyWithContext

func (c *Iam) DetachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachUserPolicyWithContext is the same as DetachUserPolicy with the addition of the ability to pass a context and additional request options.

See DetachUserPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableAccountMFADevice

func (c *Iam) EnableAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

EnableAccountMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableAccountMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableAccountMFADevice

func (*Iam) EnableAccountMFADeviceRequest

func (c *Iam) EnableAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableAccountMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the EnableAccountMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableAccountMFADevice for more information on using the EnableAccountMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableAccountMFADeviceRequest method.
req, resp := client.EnableAccountMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableAccountMFADevice

func (*Iam) EnableAccountMFADeviceWithContext

func (c *Iam) EnableAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableAccountMFADeviceWithContext is the same as EnableAccountMFADevice with the addition of the ability to pass a context and additional request options.

See EnableAccountMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableMFADevice

func (c *Iam) EnableMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

EnableMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMFADevice

func (*Iam) EnableMFADeviceRequest

func (c *Iam) EnableMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the EnableMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableMFADevice for more information on using the EnableMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableMFADeviceRequest method.
req, resp := client.EnableMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMFADevice

func (*Iam) EnableMFADeviceWithContext

func (c *Iam) EnableMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableMFADeviceWithContext is the same as EnableMFADevice with the addition of the ability to pass a context and additional request options.

See EnableMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableMfaProfile

func (c *Iam) EnableMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)

EnableMfaProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableMfaProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMfaProfile

func (*Iam) EnableMfaProfileRequest

func (c *Iam) EnableMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableMfaProfileRequest generates a "ksc/request.Request" representing the client's request for the EnableMfaProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableMfaProfile for more information on using the EnableMfaProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableMfaProfileRequest method.
req, resp := client.EnableMfaProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMfaProfile

func (*Iam) EnableMfaProfileWithContext

func (c *Iam) EnableMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableMfaProfileWithContext is the same as EnableMfaProfile with the addition of the ability to pass a context and additional request options.

See EnableMfaProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountAllProjectList

func (c *Iam) GetAccountAllProjectList(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountAllProjectList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountAllProjectList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountAllProjectList

func (*Iam) GetAccountAllProjectListRequest

func (c *Iam) GetAccountAllProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountAllProjectListRequest generates a "ksc/request.Request" representing the client's request for the GetAccountAllProjectList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountAllProjectList for more information on using the GetAccountAllProjectList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountAllProjectListRequest method.
req, resp := client.GetAccountAllProjectListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountAllProjectList

func (*Iam) GetAccountAllProjectListWithContext

func (c *Iam) GetAccountAllProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountAllProjectListWithContext is the same as GetAccountAllProjectList with the addition of the ability to pass a context and additional request options.

See GetAccountAllProjectList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectInfo

func (c *Iam) GetAccountProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectInfo

func (*Iam) GetAccountProjectInfoRequest

func (c *Iam) GetAccountProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectInfo for more information on using the GetAccountProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectInfoRequest method.
req, resp := client.GetAccountProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectInfo

func (*Iam) GetAccountProjectInfoWithContext

func (c *Iam) GetAccountProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectInfoWithContext is the same as GetAccountProjectInfo with the addition of the ability to pass a context and additional request options.

See GetAccountProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectList

func (c *Iam) GetAccountProjectList(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectList

func (*Iam) GetAccountProjectListRequest

func (c *Iam) GetAccountProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectListRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectList for more information on using the GetAccountProjectList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectListRequest method.
req, resp := client.GetAccountProjectListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectList

func (*Iam) GetAccountProjectListWithContext

func (c *Iam) GetAccountProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectListWithContext is the same as GetAccountProjectList with the addition of the ability to pass a context and additional request options.

See GetAccountProjectList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectTotal

func (c *Iam) GetAccountProjectTotal(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectTotal API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectTotal for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectTotal

func (*Iam) GetAccountProjectTotalRequest

func (c *Iam) GetAccountProjectTotalRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectTotalRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectTotal operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectTotal for more information on using the GetAccountProjectTotal API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectTotalRequest method.
req, resp := client.GetAccountProjectTotalRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectTotal

func (*Iam) GetAccountProjectTotalWithContext

func (c *Iam) GetAccountProjectTotalWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectTotalWithContext is the same as GetAccountProjectTotal with the addition of the ability to pass a context and additional request options.

See GetAccountProjectTotal for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountSummary

func (c *Iam) GetAccountSummary(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountSummary API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountSummary for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountSummary

func (*Iam) GetAccountSummaryRequest

func (c *Iam) GetAccountSummaryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountSummaryRequest generates a "ksc/request.Request" representing the client's request for the GetAccountSummary operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountSummary for more information on using the GetAccountSummary API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountSummaryRequest method.
req, resp := client.GetAccountSummaryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountSummary

func (*Iam) GetAccountSummaryWithContext

func (c *Iam) GetAccountSummaryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountSummaryWithContext is the same as GetAccountSummary with the addition of the ability to pass a context and additional request options.

See GetAccountSummary for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetGroup

func (c *Iam) GetGroup(input *map[string]interface{}) (*map[string]interface{}, error)

GetGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetGroup

func (*Iam) GetGroupRequest

func (c *Iam) GetGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetGroupRequest generates a "ksc/request.Request" representing the client's request for the GetGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetGroup for more information on using the GetGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetGroupRequest method.
req, resp := client.GetGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetGroup

func (*Iam) GetGroupWithContext

func (c *Iam) GetGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetGroupWithContext is the same as GetGroup with the addition of the ability to pass a context and additional request options.

See GetGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetLoginProfile

func (c *Iam) GetLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

GetLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetLoginProfile

func (*Iam) GetLoginProfileRequest

func (c *Iam) GetLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the GetLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLoginProfile for more information on using the GetLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLoginProfileRequest method.
req, resp := client.GetLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetLoginProfile

func (*Iam) GetLoginProfileWithContext

func (c *Iam) GetLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLoginProfileWithContext is the same as GetLoginProfile with the addition of the ability to pass a context and additional request options.

See GetLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetMfaProfile

func (c *Iam) GetMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)

GetMfaProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetMfaProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMfaProfile

func (*Iam) GetMfaProfileRequest

func (c *Iam) GetMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetMfaProfileRequest generates a "ksc/request.Request" representing the client's request for the GetMfaProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetMfaProfile for more information on using the GetMfaProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetMfaProfileRequest method.
req, resp := client.GetMfaProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMfaProfile

func (*Iam) GetMfaProfileWithContext

func (c *Iam) GetMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetMfaProfileWithContext is the same as GetMfaProfile with the addition of the ability to pass a context and additional request options.

See GetMfaProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetMiniProgramVirtualMFADevice

func (c *Iam) GetMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

GetMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMiniProgramVirtualMFADevice

func (*Iam) GetMiniProgramVirtualMFADeviceRequest

func (c *Iam) GetMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the GetMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetMiniProgramVirtualMFADevice for more information on using the GetMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetMiniProgramVirtualMFADeviceRequest method.
req, resp := client.GetMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMiniProgramVirtualMFADevice

func (*Iam) GetMiniProgramVirtualMFADeviceWithContext

func (c *Iam) GetMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetMiniProgramVirtualMFADeviceWithContext is the same as GetMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See GetMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPolicy

func (c *Iam) GetPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

GetPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicy

func (*Iam) GetPolicyRequest

func (c *Iam) GetPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPolicyRequest generates a "ksc/request.Request" representing the client's request for the GetPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPolicy for more information on using the GetPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPolicyRequest method.
req, resp := client.GetPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicy

func (*Iam) GetPolicyVersion

func (c *Iam) GetPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

GetPolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicyVersion

func (*Iam) GetPolicyVersionRequest

func (c *Iam) GetPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the GetPolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPolicyVersion for more information on using the GetPolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPolicyVersionRequest method.
req, resp := client.GetPolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicyVersion

func (*Iam) GetPolicyVersionWithContext

func (c *Iam) GetPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPolicyVersionWithContext is the same as GetPolicyVersion with the addition of the ability to pass a context and additional request options.

See GetPolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPolicyWithContext

func (c *Iam) GetPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPolicyWithContext is the same as GetPolicy with the addition of the ability to pass a context and additional request options.

See GetPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetProjectInstanceList

func (c *Iam) GetProjectInstanceList(input *map[string]interface{}) (*map[string]interface{}, error)

GetProjectInstanceList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetProjectInstanceList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetProjectInstanceList

func (*Iam) GetProjectInstanceListRequest

func (c *Iam) GetProjectInstanceListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProjectInstanceListRequest generates a "ksc/request.Request" representing the client's request for the GetProjectInstanceList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProjectInstanceList for more information on using the GetProjectInstanceList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProjectInstanceListRequest method.
req, resp := client.GetProjectInstanceListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetProjectInstanceList

func (*Iam) GetProjectInstanceListWithContext

func (c *Iam) GetProjectInstanceListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProjectInstanceListWithContext is the same as GetProjectInstanceList with the addition of the ability to pass a context and additional request options.

See GetProjectInstanceList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPwdPolicy

func (c *Iam) GetPwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

GetPwdPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPwdPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPwdPolicy

func (*Iam) GetPwdPolicyRequest

func (c *Iam) GetPwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPwdPolicyRequest generates a "ksc/request.Request" representing the client's request for the GetPwdPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPwdPolicy for more information on using the GetPwdPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPwdPolicyRequest method.
req, resp := client.GetPwdPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPwdPolicy

func (*Iam) GetPwdPolicyWithContext

func (c *Iam) GetPwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPwdPolicyWithContext is the same as GetPwdPolicy with the addition of the ability to pass a context and additional request options.

See GetPwdPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetRole

func (c *Iam) GetRole(input *map[string]interface{}) (*map[string]interface{}, error)

GetRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetRole

func (*Iam) GetRoleRequest

func (c *Iam) GetRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetRoleRequest generates a "ksc/request.Request" representing the client's request for the GetRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetRole for more information on using the GetRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetRoleRequest method.
req, resp := client.GetRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetRole

func (*Iam) GetRoleWithContext

func (c *Iam) GetRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetRoleWithContext is the same as GetRole with the addition of the ability to pass a context and additional request options.

See GetRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUser

func (c *Iam) GetUser(input *map[string]interface{}) (*map[string]interface{}, error)

GetUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUser

func (*Iam) GetUserLoginInfo

func (c *Iam) GetUserLoginInfo(input *map[string]interface{}) (*map[string]interface{}, error)

GetUserLoginInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUserLoginInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserLoginInfo

func (*Iam) GetUserLoginInfoRequest

func (c *Iam) GetUserLoginInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserLoginInfoRequest generates a "ksc/request.Request" representing the client's request for the GetUserLoginInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUserLoginInfo for more information on using the GetUserLoginInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserLoginInfoRequest method.
req, resp := client.GetUserLoginInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserLoginInfo

func (*Iam) GetUserLoginInfoWithContext

func (c *Iam) GetUserLoginInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserLoginInfoWithContext is the same as GetUserLoginInfo with the addition of the ability to pass a context and additional request options.

See GetUserLoginInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUserRequest

func (c *Iam) GetUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserRequest generates a "ksc/request.Request" representing the client's request for the GetUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUser for more information on using the GetUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserRequest method.
req, resp := client.GetUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUser

func (*Iam) GetUserSession

func (c *Iam) GetUserSession(input *map[string]interface{}) (*map[string]interface{}, error)

GetUserSession API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUserSession for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserSession

func (*Iam) GetUserSessionRequest

func (c *Iam) GetUserSessionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserSessionRequest generates a "ksc/request.Request" representing the client's request for the GetUserSession operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUserSession for more information on using the GetUserSession API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserSessionRequest method.
req, resp := client.GetUserSessionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserSession

func (*Iam) GetUserSessionWithContext

func (c *Iam) GetUserSessionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserSessionWithContext is the same as GetUserSession with the addition of the ability to pass a context and additional request options.

See GetUserSession for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUserWithContext

func (c *Iam) GetUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserWithContext is the same as GetUser with the addition of the ability to pass a context and additional request options.

See GetUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetVirtualMFADevice

func (c *Iam) GetVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

GetVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetVirtualMFADevice

func (*Iam) GetVirtualMFADeviceRequest

func (c *Iam) GetVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the GetVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetVirtualMFADevice for more information on using the GetVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetVirtualMFADeviceRequest method.
req, resp := client.GetVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetVirtualMFADevice

func (*Iam) GetVirtualMFADeviceWithContext

func (c *Iam) GetVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetVirtualMFADeviceWithContext is the same as GetVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See GetVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAccessKeys

func (c *Iam) ListAccessKeys(input *map[string]interface{}) (*map[string]interface{}, error)

ListAccessKeys API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAccessKeys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAccessKeys

func (*Iam) ListAccessKeysRequest

func (c *Iam) ListAccessKeysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAccessKeysRequest generates a "ksc/request.Request" representing the client's request for the ListAccessKeys operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAccessKeys for more information on using the ListAccessKeys API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAccessKeysRequest method.
req, resp := client.ListAccessKeysRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAccessKeys

func (*Iam) ListAccessKeysWithContext

func (c *Iam) ListAccessKeysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAccessKeysWithContext is the same as ListAccessKeys with the addition of the ability to pass a context and additional request options.

See ListAccessKeys for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListApiLogTpl

func (c *Iam) ListApiLogTpl(input *map[string]interface{}) (*map[string]interface{}, error)

ListApiLogTpl API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListApiLogTpl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListApiLogTpl

func (*Iam) ListApiLogTplRequest

func (c *Iam) ListApiLogTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListApiLogTplRequest generates a "ksc/request.Request" representing the client's request for the ListApiLogTpl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListApiLogTpl for more information on using the ListApiLogTpl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListApiLogTplRequest method.
req, resp := client.ListApiLogTplRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListApiLogTpl

func (*Iam) ListApiLogTplWithContext

func (c *Iam) ListApiLogTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListApiLogTplWithContext is the same as ListApiLogTpl with the addition of the ability to pass a context and additional request options.

See ListApiLogTpl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAttachedRolePolicies

func (c *Iam) ListAttachedRolePolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListAttachedRolePolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAttachedRolePolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedRolePolicies

func (*Iam) ListAttachedRolePoliciesRequest

func (c *Iam) ListAttachedRolePoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAttachedRolePoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListAttachedRolePolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAttachedRolePolicies for more information on using the ListAttachedRolePolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAttachedRolePoliciesRequest method.
req, resp := client.ListAttachedRolePoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedRolePolicies

func (*Iam) ListAttachedRolePoliciesWithContext

func (c *Iam) ListAttachedRolePoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAttachedRolePoliciesWithContext is the same as ListAttachedRolePolicies with the addition of the ability to pass a context and additional request options.

See ListAttachedRolePolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAttachedUserPolicies

func (c *Iam) ListAttachedUserPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListAttachedUserPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAttachedUserPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedUserPolicies

func (*Iam) ListAttachedUserPoliciesRequest

func (c *Iam) ListAttachedUserPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAttachedUserPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListAttachedUserPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAttachedUserPolicies for more information on using the ListAttachedUserPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAttachedUserPoliciesRequest method.
req, resp := client.ListAttachedUserPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedUserPolicies

func (*Iam) ListAttachedUserPoliciesWithContext

func (c *Iam) ListAttachedUserPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAttachedUserPoliciesWithContext is the same as ListAttachedUserPolicies with the addition of the ability to pass a context and additional request options.

See ListAttachedUserPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListEntitiesForPolicy

func (c *Iam) ListEntitiesForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ListEntitiesForPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListEntitiesForPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntitiesForPolicy

func (*Iam) ListEntitiesForPolicyRequest

func (c *Iam) ListEntitiesForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListEntitiesForPolicyRequest generates a "ksc/request.Request" representing the client's request for the ListEntitiesForPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListEntitiesForPolicy for more information on using the ListEntitiesForPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListEntitiesForPolicyRequest method.
req, resp := client.ListEntitiesForPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntitiesForPolicy

func (*Iam) ListEntitiesForPolicyWithContext

func (c *Iam) ListEntitiesForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListEntitiesForPolicyWithContext is the same as ListEntitiesForPolicy with the addition of the ability to pass a context and additional request options.

See ListEntitiesForPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListEntityForPolicy

func (c *Iam) ListEntityForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ListEntityForPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListEntityForPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntityForPolicy

func (*Iam) ListEntityForPolicyRequest

func (c *Iam) ListEntityForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListEntityForPolicyRequest generates a "ksc/request.Request" representing the client's request for the ListEntityForPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListEntityForPolicy for more information on using the ListEntityForPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListEntityForPolicyRequest method.
req, resp := client.ListEntityForPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntityForPolicy

func (*Iam) ListEntityForPolicyWithContext

func (c *Iam) ListEntityForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListEntityForPolicyWithContext is the same as ListEntityForPolicy with the addition of the ability to pass a context and additional request options.

See ListEntityForPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroupPolicies

func (c *Iam) ListGroupPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroupPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroupPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupPolicies

func (*Iam) ListGroupPoliciesRequest

func (c *Iam) ListGroupPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListGroupPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroupPolicies for more information on using the ListGroupPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupPoliciesRequest method.
req, resp := client.ListGroupPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupPolicies

func (*Iam) ListGroupPoliciesWithContext

func (c *Iam) ListGroupPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupPoliciesWithContext is the same as ListGroupPolicies with the addition of the ability to pass a context and additional request options.

See ListGroupPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroups

func (c *Iam) ListGroups(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroups API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroups

func (*Iam) ListGroupsForUser

func (c *Iam) ListGroupsForUser(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroupsForUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroupsForUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupsForUser

func (*Iam) ListGroupsForUserRequest

func (c *Iam) ListGroupsForUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupsForUserRequest generates a "ksc/request.Request" representing the client's request for the ListGroupsForUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroupsForUser for more information on using the ListGroupsForUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupsForUserRequest method.
req, resp := client.ListGroupsForUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupsForUser

func (*Iam) ListGroupsForUserWithContext

func (c *Iam) ListGroupsForUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupsForUserWithContext is the same as ListGroupsForUser with the addition of the ability to pass a context and additional request options.

See ListGroupsForUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroupsRequest

func (c *Iam) ListGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupsRequest generates a "ksc/request.Request" representing the client's request for the ListGroups operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroups for more information on using the ListGroups API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupsRequest method.
req, resp := client.ListGroupsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroups

func (*Iam) ListGroupsWithContext

func (c *Iam) ListGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupsWithContext is the same as ListGroups with the addition of the ability to pass a context and additional request options.

See ListGroups for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListMiniProgramVirtualMFADevice

func (c *Iam) ListMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

ListMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListMiniProgramVirtualMFADevice

func (*Iam) ListMiniProgramVirtualMFADeviceRequest

func (c *Iam) ListMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the ListMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListMiniProgramVirtualMFADevice for more information on using the ListMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListMiniProgramVirtualMFADeviceRequest method.
req, resp := client.ListMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListMiniProgramVirtualMFADevice

func (*Iam) ListMiniProgramVirtualMFADeviceWithContext

func (c *Iam) ListMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListMiniProgramVirtualMFADeviceWithContext is the same as ListMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See ListMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListPolicies

func (c *Iam) ListPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicies

func (*Iam) ListPoliciesRequest

func (c *Iam) ListPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListPolicies for more information on using the ListPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListPoliciesRequest method.
req, resp := client.ListPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicies

func (*Iam) ListPoliciesWithContext

func (c *Iam) ListPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListPoliciesWithContext is the same as ListPolicies with the addition of the ability to pass a context and additional request options.

See ListPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListPolicyVersions

func (c *Iam) ListPolicyVersions(input *map[string]interface{}) (*map[string]interface{}, error)

ListPolicyVersions API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListPolicyVersions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicyVersions

func (*Iam) ListPolicyVersionsRequest

func (c *Iam) ListPolicyVersionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListPolicyVersionsRequest generates a "ksc/request.Request" representing the client's request for the ListPolicyVersions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListPolicyVersions for more information on using the ListPolicyVersions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListPolicyVersionsRequest method.
req, resp := client.ListPolicyVersionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicyVersions

func (*Iam) ListPolicyVersionsWithContext

func (c *Iam) ListPolicyVersionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListPolicyVersionsWithContext is the same as ListPolicyVersions with the addition of the ability to pass a context and additional request options.

See ListPolicyVersions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListProjectMember

func (c *Iam) ListProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

ListProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListProjectMember

func (*Iam) ListProjectMemberRequest

func (c *Iam) ListProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the ListProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListProjectMember for more information on using the ListProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListProjectMemberRequest method.
req, resp := client.ListProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListProjectMember

func (*Iam) ListProjectMemberWithContext

func (c *Iam) ListProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListProjectMemberWithContext is the same as ListProjectMember with the addition of the ability to pass a context and additional request options.

See ListProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListResourceKrn

func (c *Iam) ListResourceKrn(input *map[string]interface{}) (*map[string]interface{}, error)

ListResourceKrn API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListResourceKrn for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListResourceKrn

func (*Iam) ListResourceKrnRequest

func (c *Iam) ListResourceKrnRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListResourceKrnRequest generates a "ksc/request.Request" representing the client's request for the ListResourceKrn operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListResourceKrn for more information on using the ListResourceKrn API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListResourceKrnRequest method.
req, resp := client.ListResourceKrnRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListResourceKrn

func (*Iam) ListResourceKrnWithContext

func (c *Iam) ListResourceKrnWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListResourceKrnWithContext is the same as ListResourceKrn with the addition of the ability to pass a context and additional request options.

See ListResourceKrn for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListRoles

func (c *Iam) ListRoles(input *map[string]interface{}) (*map[string]interface{}, error)

ListRoles API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListRoles for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListRoles

func (*Iam) ListRolesRequest

func (c *Iam) ListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListRolesRequest generates a "ksc/request.Request" representing the client's request for the ListRoles operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListRoles for more information on using the ListRoles API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListRolesRequest method.
req, resp := client.ListRolesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListRoles

func (*Iam) ListRolesWithContext

func (c *Iam) ListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListRolesWithContext is the same as ListRoles with the addition of the ability to pass a context and additional request options.

See ListRoles for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServicePerm

func (c *Iam) ListServicePerm(input *map[string]interface{}) (*map[string]interface{}, error)

ListServicePerm API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServicePerm for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicePerm

func (*Iam) ListServicePermRequest

func (c *Iam) ListServicePermRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServicePermRequest generates a "ksc/request.Request" representing the client's request for the ListServicePerm operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServicePerm for more information on using the ListServicePerm API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServicePermRequest method.
req, resp := client.ListServicePermRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicePerm

func (*Iam) ListServicePermWithContext

func (c *Iam) ListServicePermWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServicePermWithContext is the same as ListServicePerm with the addition of the ability to pass a context and additional request options.

See ListServicePerm for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServiceRolesTpl

func (c *Iam) ListServiceRolesTpl(input *map[string]interface{}) (*map[string]interface{}, error)

ListServiceRolesTpl API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServiceRolesTpl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServiceRolesTpl

func (*Iam) ListServiceRolesTplRequest

func (c *Iam) ListServiceRolesTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServiceRolesTplRequest generates a "ksc/request.Request" representing the client's request for the ListServiceRolesTpl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServiceRolesTpl for more information on using the ListServiceRolesTpl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServiceRolesTplRequest method.
req, resp := client.ListServiceRolesTplRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServiceRolesTpl

func (*Iam) ListServiceRolesTplWithContext

func (c *Iam) ListServiceRolesTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServiceRolesTplWithContext is the same as ListServiceRolesTpl with the addition of the ability to pass a context and additional request options.

See ListServiceRolesTpl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServicesAndActions

func (c *Iam) ListServicesAndActions(input *map[string]interface{}) (*map[string]interface{}, error)

ListServicesAndActions API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServicesAndActions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicesAndActions

func (*Iam) ListServicesAndActionsRequest

func (c *Iam) ListServicesAndActionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServicesAndActionsRequest generates a "ksc/request.Request" representing the client's request for the ListServicesAndActions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServicesAndActions for more information on using the ListServicesAndActions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServicesAndActionsRequest method.
req, resp := client.ListServicesAndActionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicesAndActions

func (*Iam) ListServicesAndActionsWithContext

func (c *Iam) ListServicesAndActionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServicesAndActionsWithContext is the same as ListServicesAndActions with the addition of the ability to pass a context and additional request options.

See ListServicesAndActions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListUsers

func (c *Iam) ListUsers(input *map[string]interface{}) (*map[string]interface{}, error)

ListUsers API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListUsers for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsers

func (*Iam) ListUsersByIds

func (c *Iam) ListUsersByIds(input *map[string]interface{}) (*map[string]interface{}, error)

ListUsersByIds API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListUsersByIds for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsersByIds

func (*Iam) ListUsersByIdsRequest

func (c *Iam) ListUsersByIdsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListUsersByIdsRequest generates a "ksc/request.Request" representing the client's request for the ListUsersByIds operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListUsersByIds for more information on using the ListUsersByIds API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListUsersByIdsRequest method.
req, resp := client.ListUsersByIdsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsersByIds

func (*Iam) ListUsersByIdsWithContext

func (c *Iam) ListUsersByIdsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListUsersByIdsWithContext is the same as ListUsersByIds with the addition of the ability to pass a context and additional request options.

See ListUsersByIds for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListUsersRequest

func (c *Iam) ListUsersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListUsersRequest generates a "ksc/request.Request" representing the client's request for the ListUsers operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListUsers for more information on using the ListUsers API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListUsersRequest method.
req, resp := client.ListUsersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsers

func (*Iam) ListUsersWithContext

func (c *Iam) ListUsersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListUsersWithContext is the same as ListUsers with the addition of the ability to pass a context and additional request options.

See ListUsers for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListVirtualMFADevices

func (c *Iam) ListVirtualMFADevices(input *map[string]interface{}) (*map[string]interface{}, error)

ListVirtualMFADevices API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListVirtualMFADevices for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListVirtualMFADevices

func (*Iam) ListVirtualMFADevicesRequest

func (c *Iam) ListVirtualMFADevicesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListVirtualMFADevicesRequest generates a "ksc/request.Request" representing the client's request for the ListVirtualMFADevices operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListVirtualMFADevices for more information on using the ListVirtualMFADevices API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListVirtualMFADevicesRequest method.
req, resp := client.ListVirtualMFADevicesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListVirtualMFADevices

func (*Iam) ListVirtualMFADevicesWithContext

func (c *Iam) ListVirtualMFADevicesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListVirtualMFADevicesWithContext is the same as ListVirtualMFADevices with the addition of the ability to pass a context and additional request options.

See ListVirtualMFADevices for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) RemoveUserFromGroup

func (c *Iam) RemoveUserFromGroup(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveUserFromGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation RemoveUserFromGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/RemoveUserFromGroup

func (*Iam) RemoveUserFromGroupRequest

func (c *Iam) RemoveUserFromGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveUserFromGroupRequest generates a "ksc/request.Request" representing the client's request for the RemoveUserFromGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveUserFromGroup for more information on using the RemoveUserFromGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveUserFromGroupRequest method.
req, resp := client.RemoveUserFromGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/RemoveUserFromGroup

func (*Iam) RemoveUserFromGroupWithContext

func (c *Iam) RemoveUserFromGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveUserFromGroupWithContext is the same as RemoveUserFromGroup with the addition of the ability to pass a context and additional request options.

See RemoveUserFromGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SetDefaultPolicyVersion

func (c *Iam) SetDefaultPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

SetDefaultPolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SetDefaultPolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetDefaultPolicyVersion

func (*Iam) SetDefaultPolicyVersionRequest

func (c *Iam) SetDefaultPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetDefaultPolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the SetDefaultPolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetDefaultPolicyVersion for more information on using the SetDefaultPolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetDefaultPolicyVersionRequest method.
req, resp := client.SetDefaultPolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetDefaultPolicyVersion

func (*Iam) SetDefaultPolicyVersionWithContext

func (c *Iam) SetDefaultPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetDefaultPolicyVersionWithContext is the same as SetDefaultPolicyVersion with the addition of the ability to pass a context and additional request options.

See SetDefaultPolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SetMemberViewAllProject

func (c *Iam) SetMemberViewAllProject(input *map[string]interface{}) (*map[string]interface{}, error)

SetMemberViewAllProject API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SetMemberViewAllProject for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetMemberViewAllProject

func (*Iam) SetMemberViewAllProjectRequest

func (c *Iam) SetMemberViewAllProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetMemberViewAllProjectRequest generates a "ksc/request.Request" representing the client's request for the SetMemberViewAllProject operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetMemberViewAllProject for more information on using the SetMemberViewAllProject API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetMemberViewAllProjectRequest method.
req, resp := client.SetMemberViewAllProjectRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetMemberViewAllProject

func (*Iam) SetMemberViewAllProjectWithContext

func (c *Iam) SetMemberViewAllProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetMemberViewAllProjectWithContext is the same as SetMemberViewAllProject with the addition of the ability to pass a context and additional request options.

See SetMemberViewAllProject for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SyncMiniProgramVirtualMFADevice

func (c *Iam) SyncMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

SyncMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SyncMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SyncMiniProgramVirtualMFADevice

func (*Iam) SyncMiniProgramVirtualMFADeviceRequest

func (c *Iam) SyncMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SyncMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the SyncMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SyncMiniProgramVirtualMFADevice for more information on using the SyncMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SyncMiniProgramVirtualMFADeviceRequest method.
req, resp := client.SyncMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SyncMiniProgramVirtualMFADevice

func (*Iam) SyncMiniProgramVirtualMFADeviceWithContext

func (c *Iam) SyncMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SyncMiniProgramVirtualMFADeviceWithContext is the same as SyncMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See SyncMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) Test

func (c *Iam) Test(input *map[string]interface{}) (*map[string]interface{}, error)

Test API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation Test for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/Test

func (*Iam) TestRequest

func (c *Iam) TestRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

TestRequest generates a "ksc/request.Request" representing the client's request for the Test operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See Test for more information on using the Test API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the TestRequest method.
req, resp := client.TestRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/Test

func (*Iam) TestWithContext

func (c *Iam) TestWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

TestWithContext is the same as Test with the addition of the ability to pass a context and additional request options.

See Test for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateAccessKey

func (c *Iam) UpdateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateAccessKey

func (*Iam) UpdateAccessKeyRequest

func (c *Iam) UpdateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the UpdateAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateAccessKey for more information on using the UpdateAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateAccessKeyRequest method.
req, resp := client.UpdateAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateAccessKey

func (*Iam) UpdateAccessKeyWithContext

func (c *Iam) UpdateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateAccessKeyWithContext is the same as UpdateAccessKey with the addition of the ability to pass a context and additional request options.

See UpdateAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateGroup

func (c *Iam) UpdateGroup(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateGroup

func (*Iam) UpdateGroupRequest

func (c *Iam) UpdateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateGroupRequest generates a "ksc/request.Request" representing the client's request for the UpdateGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateGroup for more information on using the UpdateGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateGroupRequest method.
req, resp := client.UpdateGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateGroup

func (*Iam) UpdateGroupWithContext

func (c *Iam) UpdateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateGroupWithContext is the same as UpdateGroup with the addition of the ability to pass a context and additional request options.

See UpdateGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateInstanceProjectId

func (c *Iam) UpdateInstanceProjectId(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateInstanceProjectId API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateInstanceProjectId for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateInstanceProjectId

func (*Iam) UpdateInstanceProjectIdRequest

func (c *Iam) UpdateInstanceProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateInstanceProjectIdRequest generates a "ksc/request.Request" representing the client's request for the UpdateInstanceProjectId operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateInstanceProjectId for more information on using the UpdateInstanceProjectId API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateInstanceProjectIdRequest method.
req, resp := client.UpdateInstanceProjectIdRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateInstanceProjectId

func (*Iam) UpdateInstanceProjectIdWithContext

func (c *Iam) UpdateInstanceProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateInstanceProjectIdWithContext is the same as UpdateInstanceProjectId with the addition of the ability to pass a context and additional request options.

See UpdateInstanceProjectId for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateLoginProfile

func (c *Iam) UpdateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateLoginProfile

func (*Iam) UpdateLoginProfileRequest

func (c *Iam) UpdateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the UpdateLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateLoginProfile for more information on using the UpdateLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateLoginProfileRequest method.
req, resp := client.UpdateLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateLoginProfile

func (*Iam) UpdateLoginProfileWithContext

func (c *Iam) UpdateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateLoginProfileWithContext is the same as UpdateLoginProfile with the addition of the ability to pass a context and additional request options.

See UpdateLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdatePolicy

func (c *Iam) UpdatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdatePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePolicy

func (*Iam) UpdatePolicyRequest

func (c *Iam) UpdatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdatePolicyRequest generates a "ksc/request.Request" representing the client's request for the UpdatePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdatePolicy for more information on using the UpdatePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdatePolicyRequest method.
req, resp := client.UpdatePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePolicy

func (*Iam) UpdatePolicyWithContext

func (c *Iam) UpdatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdatePolicyWithContext is the same as UpdatePolicy with the addition of the ability to pass a context and additional request options.

See UpdatePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateProjectInfo

func (c *Iam) UpdateProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectInfo

func (*Iam) UpdateProjectInfoRequest

func (c *Iam) UpdateProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the UpdateProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateProjectInfo for more information on using the UpdateProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateProjectInfoRequest method.
req, resp := client.UpdateProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectInfo

func (*Iam) UpdateProjectInfoWithContext

func (c *Iam) UpdateProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateProjectInfoWithContext is the same as UpdateProjectInfo with the addition of the ability to pass a context and additional request options.

See UpdateProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateProjectStatus

func (c *Iam) UpdateProjectStatus(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateProjectStatus API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateProjectStatus for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectStatus

func (*Iam) UpdateProjectStatusRequest

func (c *Iam) UpdateProjectStatusRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateProjectStatusRequest generates a "ksc/request.Request" representing the client's request for the UpdateProjectStatus operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateProjectStatus for more information on using the UpdateProjectStatus API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateProjectStatusRequest method.
req, resp := client.UpdateProjectStatusRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectStatus

func (*Iam) UpdateProjectStatusWithContext

func (c *Iam) UpdateProjectStatusWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateProjectStatusWithContext is the same as UpdateProjectStatus with the addition of the ability to pass a context and additional request options.

See UpdateProjectStatus for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdatePwdPolicy

func (c *Iam) UpdatePwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePwdPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdatePwdPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePwdPolicy

func (*Iam) UpdatePwdPolicyRequest

func (c *Iam) UpdatePwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdatePwdPolicyRequest generates a "ksc/request.Request" representing the client's request for the UpdatePwdPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdatePwdPolicy for more information on using the UpdatePwdPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdatePwdPolicyRequest method.
req, resp := client.UpdatePwdPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePwdPolicy

func (*Iam) UpdatePwdPolicyWithContext

func (c *Iam) UpdatePwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdatePwdPolicyWithContext is the same as UpdatePwdPolicy with the addition of the ability to pass a context and additional request options.

See UpdatePwdPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateRole

func (c *Iam) UpdateRole(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRole

func (*Iam) UpdateRoleRequest

func (c *Iam) UpdateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateRoleRequest generates a "ksc/request.Request" representing the client's request for the UpdateRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateRole for more information on using the UpdateRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateRoleRequest method.
req, resp := client.UpdateRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRole

func (*Iam) UpdateRoleTrustAccounts

func (c *Iam) UpdateRoleTrustAccounts(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateRoleTrustAccounts API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateRoleTrustAccounts for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRoleTrustAccounts

func (*Iam) UpdateRoleTrustAccountsRequest

func (c *Iam) UpdateRoleTrustAccountsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateRoleTrustAccountsRequest generates a "ksc/request.Request" representing the client's request for the UpdateRoleTrustAccounts operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateRoleTrustAccounts for more information on using the UpdateRoleTrustAccounts API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateRoleTrustAccountsRequest method.
req, resp := client.UpdateRoleTrustAccountsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRoleTrustAccounts

func (*Iam) UpdateRoleTrustAccountsWithContext

func (c *Iam) UpdateRoleTrustAccountsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateRoleTrustAccountsWithContext is the same as UpdateRoleTrustAccounts with the addition of the ability to pass a context and additional request options.

See UpdateRoleTrustAccounts for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateRoleWithContext

func (c *Iam) UpdateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateRoleWithContext is the same as UpdateRole with the addition of the ability to pass a context and additional request options.

See UpdateRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateUser

func (c *Iam) UpdateUser(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUser

func (*Iam) UpdateUserContactInfo

func (c *Iam) UpdateUserContactInfo(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateUserContactInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateUserContactInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUserContactInfo

func (*Iam) UpdateUserContactInfoRequest

func (c *Iam) UpdateUserContactInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateUserContactInfoRequest generates a "ksc/request.Request" representing the client's request for the UpdateUserContactInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateUserContactInfo for more information on using the UpdateUserContactInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateUserContactInfoRequest method.
req, resp := client.UpdateUserContactInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUserContactInfo

func (*Iam) UpdateUserContactInfoWithContext

func (c *Iam) UpdateUserContactInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateUserContactInfoWithContext is the same as UpdateUserContactInfo with the addition of the ability to pass a context and additional request options.

See UpdateUserContactInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateUserRequest

func (c *Iam) UpdateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateUserRequest generates a "ksc/request.Request" representing the client's request for the UpdateUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateUser for more information on using the UpdateUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateUserRequest method.
req, resp := client.UpdateUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUser

func (*Iam) UpdateUserWithContext

func (c *Iam) UpdateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateUserWithContext is the same as UpdateUser with the addition of the ability to pass a context and additional request options.

See UpdateUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UserLogin

func (c *Iam) UserLogin(input *map[string]interface{}) (*map[string]interface{}, error)

UserLogin API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UserLogin for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UserLogin

func (*Iam) UserLoginRequest

func (c *Iam) UserLoginRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UserLoginRequest generates a "ksc/request.Request" representing the client's request for the UserLogin operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UserLogin for more information on using the UserLogin API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UserLoginRequest method.
req, resp := client.UserLoginRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UserLogin

func (*Iam) UserLoginWithContext

func (c *Iam) UserLoginWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UserLoginWithContext is the same as UserLogin with the addition of the ability to pass a context and additional request options.

See UserLogin for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ValidPolicyDocument

func (c *Iam) ValidPolicyDocument(input *map[string]interface{}) (*map[string]interface{}, error)

ValidPolicyDocument API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ValidPolicyDocument for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidPolicyDocument

func (*Iam) ValidPolicyDocumentRequest

func (c *Iam) ValidPolicyDocumentRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ValidPolicyDocumentRequest generates a "ksc/request.Request" representing the client's request for the ValidPolicyDocument operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ValidPolicyDocument for more information on using the ValidPolicyDocument API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ValidPolicyDocumentRequest method.
req, resp := client.ValidPolicyDocumentRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidPolicyDocument

func (*Iam) ValidPolicyDocumentWithContext

func (c *Iam) ValidPolicyDocumentWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ValidPolicyDocumentWithContext is the same as ValidPolicyDocument with the addition of the ability to pass a context and additional request options.

See ValidPolicyDocument for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ValidProjectId

func (c *Iam) ValidProjectId(input *map[string]interface{}) (*map[string]interface{}, error)

ValidProjectId API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ValidProjectId for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidProjectId

func (*Iam) ValidProjectIdRequest

func (c *Iam) ValidProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ValidProjectIdRequest generates a "ksc/request.Request" representing the client's request for the ValidProjectId operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ValidProjectId for more information on using the ValidProjectId API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ValidProjectIdRequest method.
req, resp := client.ValidProjectIdRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidProjectId

func (*Iam) ValidProjectIdWithContext

func (c *Iam) ValidProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ValidProjectIdWithContext is the same as ValidProjectId with the addition of the ability to pass a context and additional request options.

See ValidProjectId for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerificateCompany

func (c *Iam) VerificateCompany(input *map[string]interface{}) (*map[string]interface{}, error)

VerificateCompany API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerificateCompany for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificateCompany

func (*Iam) VerificateCompanyRequest

func (c *Iam) VerificateCompanyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerificateCompanyRequest generates a "ksc/request.Request" representing the client's request for the VerificateCompany operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerificateCompany for more information on using the VerificateCompany API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerificateCompanyRequest method.
req, resp := client.VerificateCompanyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificateCompany

func (*Iam) VerificateCompanyWithContext

func (c *Iam) VerificateCompanyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerificateCompanyWithContext is the same as VerificateCompany with the addition of the ability to pass a context and additional request options.

See VerificateCompany for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerificatePerson

func (c *Iam) VerificatePerson(input *map[string]interface{}) (*map[string]interface{}, error)

VerificatePerson API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerificatePerson for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificatePerson

func (*Iam) VerificatePersonRequest

func (c *Iam) VerificatePersonRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerificatePersonRequest generates a "ksc/request.Request" representing the client's request for the VerificatePerson operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerificatePerson for more information on using the VerificatePerson API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerificatePersonRequest method.
req, resp := client.VerificatePersonRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificatePerson

func (*Iam) VerificatePersonWithContext

func (c *Iam) VerificatePersonWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerificatePersonWithContext is the same as VerificatePerson with the addition of the ability to pass a context and additional request options.

See VerificatePerson for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerifyMFACode

func (c *Iam) VerifyMFACode(input *map[string]interface{}) (*map[string]interface{}, error)

VerifyMFACode API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerifyMFACode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerifyMFACode

func (*Iam) VerifyMFACodeRequest

func (c *Iam) VerifyMFACodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerifyMFACodeRequest generates a "ksc/request.Request" representing the client's request for the VerifyMFACode operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerifyMFACode for more information on using the VerifyMFACode API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerifyMFACodeRequest method.
req, resp := client.VerifyMFACodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerifyMFACode

func (*Iam) VerifyMFACodeWithContext

func (c *Iam) VerifyMFACodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerifyMFACodeWithContext is the same as VerifyMFACode with the addition of the ability to pass a context and additional request options.

See VerifyMFACode for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.