// Code generated by mockery v0.0.0-dev. DO NOT EDIT.

package aws

import (
	context "context"

	iam "github.com/aws/aws-sdk-go/service/iam"
	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"
)

// MockFakeIAM is an autogenerated mock type for the FakeIAM type
type MockFakeIAM struct {
	mock.Mock
}

// AddClientIDToOpenIDConnectProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddClientIDToOpenIDConnectProvider(_a0 *iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AddClientIDToOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.AddClientIDToOpenIDConnectProviderInput) *iam.AddClientIDToOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddClientIDToOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AddClientIDToOpenIDConnectProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddClientIDToOpenIDConnectProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddClientIDToOpenIDConnectProviderRequest(_a0 *iam.AddClientIDToOpenIDConnectProviderInput) (*request.Request, *iam.AddClientIDToOpenIDConnectProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AddClientIDToOpenIDConnectProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AddClientIDToOpenIDConnectProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.AddClientIDToOpenIDConnectProviderInput) *iam.AddClientIDToOpenIDConnectProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AddClientIDToOpenIDConnectProviderOutput)
		}
	}

	return r0, r1
}

// AddClientIDToOpenIDConnectProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AddClientIDToOpenIDConnectProviderWithContext(_a0 context.Context, _a1 *iam.AddClientIDToOpenIDConnectProviderInput, _a2 ...request.Option) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AddClientIDToOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AddClientIDToOpenIDConnectProviderInput, ...request.Option) *iam.AddClientIDToOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddClientIDToOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AddClientIDToOpenIDConnectProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRoleToInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddRoleToInstanceProfile(_a0 *iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AddRoleToInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.AddRoleToInstanceProfileInput) *iam.AddRoleToInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddRoleToInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AddRoleToInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRoleToInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddRoleToInstanceProfileRequest(_a0 *iam.AddRoleToInstanceProfileInput) (*request.Request, *iam.AddRoleToInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AddRoleToInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AddRoleToInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.AddRoleToInstanceProfileInput) *iam.AddRoleToInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AddRoleToInstanceProfileOutput)
		}
	}

	return r0, r1
}

// AddRoleToInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AddRoleToInstanceProfileWithContext(_a0 context.Context, _a1 *iam.AddRoleToInstanceProfileInput, _a2 ...request.Option) (*iam.AddRoleToInstanceProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AddRoleToInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AddRoleToInstanceProfileInput, ...request.Option) *iam.AddRoleToInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddRoleToInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AddRoleToInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddUserToGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddUserToGroup(_a0 *iam.AddUserToGroupInput) (*iam.AddUserToGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AddUserToGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.AddUserToGroupInput) *iam.AddUserToGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddUserToGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AddUserToGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddUserToGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AddUserToGroupRequest(_a0 *iam.AddUserToGroupInput) (*request.Request, *iam.AddUserToGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AddUserToGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AddUserToGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.AddUserToGroupInput) *iam.AddUserToGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AddUserToGroupOutput)
		}
	}

	return r0, r1
}

// AddUserToGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AddUserToGroupWithContext(_a0 context.Context, _a1 *iam.AddUserToGroupInput, _a2 ...request.Option) (*iam.AddUserToGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AddUserToGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AddUserToGroupInput, ...request.Option) *iam.AddUserToGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AddUserToGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AddUserToGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachGroupPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachGroupPolicy(_a0 *iam.AttachGroupPolicyInput) (*iam.AttachGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AttachGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.AttachGroupPolicyInput) *iam.AttachGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AttachGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachGroupPolicyRequest(_a0 *iam.AttachGroupPolicyInput) (*request.Request, *iam.AttachGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AttachGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AttachGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.AttachGroupPolicyInput) *iam.AttachGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AttachGroupPolicyOutput)
		}
	}

	return r0, r1
}

// AttachGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AttachGroupPolicyWithContext(_a0 context.Context, _a1 *iam.AttachGroupPolicyInput, _a2 ...request.Option) (*iam.AttachGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AttachGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AttachGroupPolicyInput, ...request.Option) *iam.AttachGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AttachGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachRolePolicy(_a0 *iam.AttachRolePolicyInput) (*iam.AttachRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AttachRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.AttachRolePolicyInput) *iam.AttachRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AttachRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachRolePolicyRequest(_a0 *iam.AttachRolePolicyInput) (*request.Request, *iam.AttachRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AttachRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AttachRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.AttachRolePolicyInput) *iam.AttachRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AttachRolePolicyOutput)
		}
	}

	return r0, r1
}

// AttachRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AttachRolePolicyWithContext(_a0 context.Context, _a1 *iam.AttachRolePolicyInput, _a2 ...request.Option) (*iam.AttachRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AttachRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AttachRolePolicyInput, ...request.Option) *iam.AttachRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AttachRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachUserPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachUserPolicy(_a0 *iam.AttachUserPolicyInput) (*iam.AttachUserPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.AttachUserPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.AttachUserPolicyInput) *iam.AttachUserPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.AttachUserPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AttachUserPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) AttachUserPolicyRequest(_a0 *iam.AttachUserPolicyInput) (*request.Request, *iam.AttachUserPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.AttachUserPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.AttachUserPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.AttachUserPolicyInput) *iam.AttachUserPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.AttachUserPolicyOutput)
		}
	}

	return r0, r1
}

// AttachUserPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) AttachUserPolicyWithContext(_a0 context.Context, _a1 *iam.AttachUserPolicyInput, _a2 ...request.Option) (*iam.AttachUserPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.AttachUserPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.AttachUserPolicyInput, ...request.Option) *iam.AttachUserPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.AttachUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.AttachUserPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangePassword provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ChangePassword(_a0 *iam.ChangePasswordInput) (*iam.ChangePasswordOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ChangePasswordOutput
	if rf, ok := ret.Get(0).(func(*iam.ChangePasswordInput) *iam.ChangePasswordOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ChangePasswordOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ChangePasswordInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChangePasswordRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ChangePasswordRequest(_a0 *iam.ChangePasswordInput) (*request.Request, *iam.ChangePasswordOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ChangePasswordInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ChangePasswordOutput
	if rf, ok := ret.Get(1).(func(*iam.ChangePasswordInput) *iam.ChangePasswordOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ChangePasswordOutput)
		}
	}

	return r0, r1
}

// ChangePasswordWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ChangePasswordWithContext(_a0 context.Context, _a1 *iam.ChangePasswordInput, _a2 ...request.Option) (*iam.ChangePasswordOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ChangePasswordOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ChangePasswordInput, ...request.Option) *iam.ChangePasswordOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ChangePasswordOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ChangePasswordInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAccessKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateAccessKey(_a0 *iam.CreateAccessKeyInput) (*iam.CreateAccessKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateAccessKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateAccessKeyInput) *iam.CreateAccessKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateAccessKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAccessKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateAccessKeyRequest(_a0 *iam.CreateAccessKeyInput) (*request.Request, *iam.CreateAccessKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateAccessKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateAccessKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateAccessKeyInput) *iam.CreateAccessKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateAccessKeyOutput)
		}
	}

	return r0, r1
}

// CreateAccessKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateAccessKeyWithContext(_a0 context.Context, _a1 *iam.CreateAccessKeyInput, _a2 ...request.Option) (*iam.CreateAccessKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateAccessKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateAccessKeyInput, ...request.Option) *iam.CreateAccessKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateAccessKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAccountAlias provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateAccountAlias(_a0 *iam.CreateAccountAliasInput) (*iam.CreateAccountAliasOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateAccountAliasOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateAccountAliasInput) *iam.CreateAccountAliasOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateAccountAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateAccountAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAccountAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateAccountAliasRequest(_a0 *iam.CreateAccountAliasInput) (*request.Request, *iam.CreateAccountAliasOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateAccountAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateAccountAliasOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateAccountAliasInput) *iam.CreateAccountAliasOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateAccountAliasOutput)
		}
	}

	return r0, r1
}

// CreateAccountAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateAccountAliasWithContext(_a0 context.Context, _a1 *iam.CreateAccountAliasInput, _a2 ...request.Option) (*iam.CreateAccountAliasOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateAccountAliasOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateAccountAliasInput, ...request.Option) *iam.CreateAccountAliasOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateAccountAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateAccountAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateGroup(_a0 *iam.CreateGroupInput) (*iam.CreateGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateGroupInput) *iam.CreateGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateGroupRequest(_a0 *iam.CreateGroupInput) (*request.Request, *iam.CreateGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateGroupInput) *iam.CreateGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateGroupOutput)
		}
	}

	return r0, r1
}

// CreateGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateGroupWithContext(_a0 context.Context, _a1 *iam.CreateGroupInput, _a2 ...request.Option) (*iam.CreateGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateGroupInput, ...request.Option) *iam.CreateGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateInstanceProfile(_a0 *iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateInstanceProfileInput) *iam.CreateInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateInstanceProfileRequest(_a0 *iam.CreateInstanceProfileInput) (*request.Request, *iam.CreateInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateInstanceProfileInput) *iam.CreateInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateInstanceProfileOutput)
		}
	}

	return r0, r1
}

// CreateInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateInstanceProfileWithContext(_a0 context.Context, _a1 *iam.CreateInstanceProfileInput, _a2 ...request.Option) (*iam.CreateInstanceProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateInstanceProfileInput, ...request.Option) *iam.CreateInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateLoginProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateLoginProfile(_a0 *iam.CreateLoginProfileInput) (*iam.CreateLoginProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateLoginProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateLoginProfileInput) *iam.CreateLoginProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateLoginProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateLoginProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateLoginProfileRequest(_a0 *iam.CreateLoginProfileInput) (*request.Request, *iam.CreateLoginProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateLoginProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateLoginProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateLoginProfileInput) *iam.CreateLoginProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateLoginProfileOutput)
		}
	}

	return r0, r1
}

// CreateLoginProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateLoginProfileWithContext(_a0 context.Context, _a1 *iam.CreateLoginProfileInput, _a2 ...request.Option) (*iam.CreateLoginProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateLoginProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateLoginProfileInput, ...request.Option) *iam.CreateLoginProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateLoginProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOpenIDConnectProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateOpenIDConnectProvider(_a0 *iam.CreateOpenIDConnectProviderInput) (*iam.CreateOpenIDConnectProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateOpenIDConnectProviderInput) *iam.CreateOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateOpenIDConnectProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOpenIDConnectProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateOpenIDConnectProviderRequest(_a0 *iam.CreateOpenIDConnectProviderInput) (*request.Request, *iam.CreateOpenIDConnectProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateOpenIDConnectProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateOpenIDConnectProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateOpenIDConnectProviderInput) *iam.CreateOpenIDConnectProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateOpenIDConnectProviderOutput)
		}
	}

	return r0, r1
}

// CreateOpenIDConnectProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateOpenIDConnectProviderWithContext(_a0 context.Context, _a1 *iam.CreateOpenIDConnectProviderInput, _a2 ...request.Option) (*iam.CreateOpenIDConnectProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateOpenIDConnectProviderInput, ...request.Option) *iam.CreateOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateOpenIDConnectProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreatePolicy(_a0 *iam.CreatePolicyInput) (*iam.CreatePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreatePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.CreatePolicyInput) *iam.CreatePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreatePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreatePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreatePolicyRequest(_a0 *iam.CreatePolicyInput) (*request.Request, *iam.CreatePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreatePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreatePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.CreatePolicyInput) *iam.CreatePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreatePolicyOutput)
		}
	}

	return r0, r1
}

// CreatePolicyVersion provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreatePolicyVersion(_a0 *iam.CreatePolicyVersionInput) (*iam.CreatePolicyVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreatePolicyVersionOutput
	if rf, ok := ret.Get(0).(func(*iam.CreatePolicyVersionInput) *iam.CreatePolicyVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreatePolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreatePolicyVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePolicyVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreatePolicyVersionRequest(_a0 *iam.CreatePolicyVersionInput) (*request.Request, *iam.CreatePolicyVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreatePolicyVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreatePolicyVersionOutput
	if rf, ok := ret.Get(1).(func(*iam.CreatePolicyVersionInput) *iam.CreatePolicyVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreatePolicyVersionOutput)
		}
	}

	return r0, r1
}

// CreatePolicyVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreatePolicyVersionWithContext(_a0 context.Context, _a1 *iam.CreatePolicyVersionInput, _a2 ...request.Option) (*iam.CreatePolicyVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreatePolicyVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreatePolicyVersionInput, ...request.Option) *iam.CreatePolicyVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreatePolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreatePolicyVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreatePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreatePolicyWithContext(_a0 context.Context, _a1 *iam.CreatePolicyInput, _a2 ...request.Option) (*iam.CreatePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreatePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreatePolicyInput, ...request.Option) *iam.CreatePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreatePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreatePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateRole(_a0 *iam.CreateRoleInput) (*iam.CreateRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateRoleInput) *iam.CreateRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateRoleRequest(_a0 *iam.CreateRoleInput) (*request.Request, *iam.CreateRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateRoleInput) *iam.CreateRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateRoleOutput)
		}
	}

	return r0, r1
}

// CreateRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateRoleWithContext(_a0 context.Context, _a1 *iam.CreateRoleInput, _a2 ...request.Option) (*iam.CreateRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateRoleInput, ...request.Option) *iam.CreateRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateSAMLProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateSAMLProvider(_a0 *iam.CreateSAMLProviderInput) (*iam.CreateSAMLProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateSAMLProviderInput) *iam.CreateSAMLProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateSAMLProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateSAMLProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateSAMLProviderRequest(_a0 *iam.CreateSAMLProviderInput) (*request.Request, *iam.CreateSAMLProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateSAMLProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateSAMLProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateSAMLProviderInput) *iam.CreateSAMLProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateSAMLProviderOutput)
		}
	}

	return r0, r1
}

// CreateSAMLProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateSAMLProviderWithContext(_a0 context.Context, _a1 *iam.CreateSAMLProviderInput, _a2 ...request.Option) (*iam.CreateSAMLProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateSAMLProviderInput, ...request.Option) *iam.CreateSAMLProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateSAMLProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateServiceLinkedRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateServiceLinkedRole(_a0 *iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateServiceLinkedRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateServiceLinkedRoleInput) *iam.CreateServiceLinkedRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateServiceLinkedRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateServiceLinkedRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateServiceLinkedRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateServiceLinkedRoleRequest(_a0 *iam.CreateServiceLinkedRoleInput) (*request.Request, *iam.CreateServiceLinkedRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateServiceLinkedRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateServiceLinkedRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateServiceLinkedRoleInput) *iam.CreateServiceLinkedRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateServiceLinkedRoleOutput)
		}
	}

	return r0, r1
}

// CreateServiceLinkedRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateServiceLinkedRoleWithContext(_a0 context.Context, _a1 *iam.CreateServiceLinkedRoleInput, _a2 ...request.Option) (*iam.CreateServiceLinkedRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateServiceLinkedRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateServiceLinkedRoleInput, ...request.Option) *iam.CreateServiceLinkedRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateServiceLinkedRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateServiceLinkedRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateServiceSpecificCredential provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateServiceSpecificCredential(_a0 *iam.CreateServiceSpecificCredentialInput) (*iam.CreateServiceSpecificCredentialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateServiceSpecificCredentialInput) *iam.CreateServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateServiceSpecificCredentialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateServiceSpecificCredentialRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateServiceSpecificCredentialRequest(_a0 *iam.CreateServiceSpecificCredentialInput) (*request.Request, *iam.CreateServiceSpecificCredentialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateServiceSpecificCredentialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateServiceSpecificCredentialInput) *iam.CreateServiceSpecificCredentialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateServiceSpecificCredentialOutput)
		}
	}

	return r0, r1
}

// CreateServiceSpecificCredentialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateServiceSpecificCredentialWithContext(_a0 context.Context, _a1 *iam.CreateServiceSpecificCredentialInput, _a2 ...request.Option) (*iam.CreateServiceSpecificCredentialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateServiceSpecificCredentialInput, ...request.Option) *iam.CreateServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateServiceSpecificCredentialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateUser(_a0 *iam.CreateUserInput) (*iam.CreateUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateUserOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateUserInput) *iam.CreateUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateUserRequest(_a0 *iam.CreateUserInput) (*request.Request, *iam.CreateUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateUserOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateUserInput) *iam.CreateUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateUserOutput)
		}
	}

	return r0, r1
}

// CreateUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateUserWithContext(_a0 context.Context, _a1 *iam.CreateUserInput, _a2 ...request.Option) (*iam.CreateUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateUserInput, ...request.Option) *iam.CreateUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateVirtualMFADevice provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateVirtualMFADevice(_a0 *iam.CreateVirtualMFADeviceInput) (*iam.CreateVirtualMFADeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.CreateVirtualMFADeviceOutput
	if rf, ok := ret.Get(0).(func(*iam.CreateVirtualMFADeviceInput) *iam.CreateVirtualMFADeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateVirtualMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.CreateVirtualMFADeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateVirtualMFADeviceRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) CreateVirtualMFADeviceRequest(_a0 *iam.CreateVirtualMFADeviceInput) (*request.Request, *iam.CreateVirtualMFADeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.CreateVirtualMFADeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.CreateVirtualMFADeviceOutput
	if rf, ok := ret.Get(1).(func(*iam.CreateVirtualMFADeviceInput) *iam.CreateVirtualMFADeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.CreateVirtualMFADeviceOutput)
		}
	}

	return r0, r1
}

// CreateVirtualMFADeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) CreateVirtualMFADeviceWithContext(_a0 context.Context, _a1 *iam.CreateVirtualMFADeviceInput, _a2 ...request.Option) (*iam.CreateVirtualMFADeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.CreateVirtualMFADeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.CreateVirtualMFADeviceInput, ...request.Option) *iam.CreateVirtualMFADeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.CreateVirtualMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.CreateVirtualMFADeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeactivateMFADevice provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeactivateMFADevice(_a0 *iam.DeactivateMFADeviceInput) (*iam.DeactivateMFADeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeactivateMFADeviceOutput
	if rf, ok := ret.Get(0).(func(*iam.DeactivateMFADeviceInput) *iam.DeactivateMFADeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeactivateMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeactivateMFADeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeactivateMFADeviceRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeactivateMFADeviceRequest(_a0 *iam.DeactivateMFADeviceInput) (*request.Request, *iam.DeactivateMFADeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeactivateMFADeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeactivateMFADeviceOutput
	if rf, ok := ret.Get(1).(func(*iam.DeactivateMFADeviceInput) *iam.DeactivateMFADeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeactivateMFADeviceOutput)
		}
	}

	return r0, r1
}

// DeactivateMFADeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeactivateMFADeviceWithContext(_a0 context.Context, _a1 *iam.DeactivateMFADeviceInput, _a2 ...request.Option) (*iam.DeactivateMFADeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeactivateMFADeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeactivateMFADeviceInput, ...request.Option) *iam.DeactivateMFADeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeactivateMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeactivateMFADeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccessKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccessKey(_a0 *iam.DeleteAccessKeyInput) (*iam.DeleteAccessKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteAccessKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccessKeyInput) *iam.DeleteAccessKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccessKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccessKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccessKeyRequest(_a0 *iam.DeleteAccessKeyInput) (*request.Request, *iam.DeleteAccessKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccessKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteAccessKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccessKeyInput) *iam.DeleteAccessKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteAccessKeyOutput)
		}
	}

	return r0, r1
}

// DeleteAccessKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteAccessKeyWithContext(_a0 context.Context, _a1 *iam.DeleteAccessKeyInput, _a2 ...request.Option) (*iam.DeleteAccessKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteAccessKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteAccessKeyInput, ...request.Option) *iam.DeleteAccessKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteAccessKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccountAlias provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccountAlias(_a0 *iam.DeleteAccountAliasInput) (*iam.DeleteAccountAliasOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteAccountAliasOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccountAliasInput) *iam.DeleteAccountAliasOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccountAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccountAliasInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccountAliasRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccountAliasRequest(_a0 *iam.DeleteAccountAliasInput) (*request.Request, *iam.DeleteAccountAliasOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccountAliasInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteAccountAliasOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccountAliasInput) *iam.DeleteAccountAliasOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteAccountAliasOutput)
		}
	}

	return r0, r1
}

// DeleteAccountAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteAccountAliasWithContext(_a0 context.Context, _a1 *iam.DeleteAccountAliasInput, _a2 ...request.Option) (*iam.DeleteAccountAliasOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteAccountAliasOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteAccountAliasInput, ...request.Option) *iam.DeleteAccountAliasOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccountAliasOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteAccountAliasInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccountPasswordPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccountPasswordPolicy(_a0 *iam.DeleteAccountPasswordPolicyInput) (*iam.DeleteAccountPasswordPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccountPasswordPolicyInput) *iam.DeleteAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccountPasswordPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAccountPasswordPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteAccountPasswordPolicyRequest(_a0 *iam.DeleteAccountPasswordPolicyInput) (*request.Request, *iam.DeleteAccountPasswordPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteAccountPasswordPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteAccountPasswordPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteAccountPasswordPolicyInput) *iam.DeleteAccountPasswordPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteAccountPasswordPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteAccountPasswordPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteAccountPasswordPolicyWithContext(_a0 context.Context, _a1 *iam.DeleteAccountPasswordPolicyInput, _a2 ...request.Option) (*iam.DeleteAccountPasswordPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteAccountPasswordPolicyInput, ...request.Option) *iam.DeleteAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteAccountPasswordPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteGroup(_a0 *iam.DeleteGroupInput) (*iam.DeleteGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteGroupInput) *iam.DeleteGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGroupPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteGroupPolicy(_a0 *iam.DeleteGroupPolicyInput) (*iam.DeleteGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteGroupPolicyInput) *iam.DeleteGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteGroupPolicyRequest(_a0 *iam.DeleteGroupPolicyInput) (*request.Request, *iam.DeleteGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteGroupPolicyInput) *iam.DeleteGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteGroupPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteGroupPolicyWithContext(_a0 context.Context, _a1 *iam.DeleteGroupPolicyInput, _a2 ...request.Option) (*iam.DeleteGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteGroupPolicyInput, ...request.Option) *iam.DeleteGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteGroupRequest(_a0 *iam.DeleteGroupInput) (*request.Request, *iam.DeleteGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteGroupInput) *iam.DeleteGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteGroupOutput)
		}
	}

	return r0, r1
}

// DeleteGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteGroupWithContext(_a0 context.Context, _a1 *iam.DeleteGroupInput, _a2 ...request.Option) (*iam.DeleteGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteGroupInput, ...request.Option) *iam.DeleteGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteInstanceProfile(_a0 *iam.DeleteInstanceProfileInput) (*iam.DeleteInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteInstanceProfileInput) *iam.DeleteInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteInstanceProfileRequest(_a0 *iam.DeleteInstanceProfileInput) (*request.Request, *iam.DeleteInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteInstanceProfileInput) *iam.DeleteInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteInstanceProfileOutput)
		}
	}

	return r0, r1
}

// DeleteInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteInstanceProfileWithContext(_a0 context.Context, _a1 *iam.DeleteInstanceProfileInput, _a2 ...request.Option) (*iam.DeleteInstanceProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteInstanceProfileInput, ...request.Option) *iam.DeleteInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLoginProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteLoginProfile(_a0 *iam.DeleteLoginProfileInput) (*iam.DeleteLoginProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteLoginProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteLoginProfileInput) *iam.DeleteLoginProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteLoginProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteLoginProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteLoginProfileRequest(_a0 *iam.DeleteLoginProfileInput) (*request.Request, *iam.DeleteLoginProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteLoginProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteLoginProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteLoginProfileInput) *iam.DeleteLoginProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteLoginProfileOutput)
		}
	}

	return r0, r1
}

// DeleteLoginProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteLoginProfileWithContext(_a0 context.Context, _a1 *iam.DeleteLoginProfileInput, _a2 ...request.Option) (*iam.DeleteLoginProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteLoginProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteLoginProfileInput, ...request.Option) *iam.DeleteLoginProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteLoginProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteOpenIDConnectProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteOpenIDConnectProvider(_a0 *iam.DeleteOpenIDConnectProviderInput) (*iam.DeleteOpenIDConnectProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteOpenIDConnectProviderInput) *iam.DeleteOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteOpenIDConnectProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteOpenIDConnectProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteOpenIDConnectProviderRequest(_a0 *iam.DeleteOpenIDConnectProviderInput) (*request.Request, *iam.DeleteOpenIDConnectProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteOpenIDConnectProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteOpenIDConnectProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteOpenIDConnectProviderInput) *iam.DeleteOpenIDConnectProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteOpenIDConnectProviderOutput)
		}
	}

	return r0, r1
}

// DeleteOpenIDConnectProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteOpenIDConnectProviderWithContext(_a0 context.Context, _a1 *iam.DeleteOpenIDConnectProviderInput, _a2 ...request.Option) (*iam.DeleteOpenIDConnectProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteOpenIDConnectProviderInput, ...request.Option) *iam.DeleteOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteOpenIDConnectProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeletePolicy(_a0 *iam.DeletePolicyInput) (*iam.DeletePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeletePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeletePolicyInput) *iam.DeletePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeletePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeletePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeletePolicyRequest(_a0 *iam.DeletePolicyInput) (*request.Request, *iam.DeletePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeletePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeletePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeletePolicyInput) *iam.DeletePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeletePolicyOutput)
		}
	}

	return r0, r1
}

// DeletePolicyVersion provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeletePolicyVersion(_a0 *iam.DeletePolicyVersionInput) (*iam.DeletePolicyVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeletePolicyVersionOutput
	if rf, ok := ret.Get(0).(func(*iam.DeletePolicyVersionInput) *iam.DeletePolicyVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeletePolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeletePolicyVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePolicyVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeletePolicyVersionRequest(_a0 *iam.DeletePolicyVersionInput) (*request.Request, *iam.DeletePolicyVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeletePolicyVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeletePolicyVersionOutput
	if rf, ok := ret.Get(1).(func(*iam.DeletePolicyVersionInput) *iam.DeletePolicyVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeletePolicyVersionOutput)
		}
	}

	return r0, r1
}

// DeletePolicyVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeletePolicyVersionWithContext(_a0 context.Context, _a1 *iam.DeletePolicyVersionInput, _a2 ...request.Option) (*iam.DeletePolicyVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeletePolicyVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeletePolicyVersionInput, ...request.Option) *iam.DeletePolicyVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeletePolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeletePolicyVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeletePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeletePolicyWithContext(_a0 context.Context, _a1 *iam.DeletePolicyInput, _a2 ...request.Option) (*iam.DeletePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeletePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeletePolicyInput, ...request.Option) *iam.DeletePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeletePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeletePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRole(_a0 *iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteRoleInput) *iam.DeleteRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRolePermissionsBoundary provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRolePermissionsBoundary(_a0 *iam.DeleteRolePermissionsBoundaryInput) (*iam.DeleteRolePermissionsBoundaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteRolePermissionsBoundaryInput) *iam.DeleteRolePermissionsBoundaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRolePermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteRolePermissionsBoundaryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRolePermissionsBoundaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRolePermissionsBoundaryRequest(_a0 *iam.DeleteRolePermissionsBoundaryInput) (*request.Request, *iam.DeleteRolePermissionsBoundaryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteRolePermissionsBoundaryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteRolePermissionsBoundaryInput) *iam.DeleteRolePermissionsBoundaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteRolePermissionsBoundaryOutput)
		}
	}

	return r0, r1
}

// DeleteRolePermissionsBoundaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteRolePermissionsBoundaryWithContext(_a0 context.Context, _a1 *iam.DeleteRolePermissionsBoundaryInput, _a2 ...request.Option) (*iam.DeleteRolePermissionsBoundaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteRolePermissionsBoundaryInput, ...request.Option) *iam.DeleteRolePermissionsBoundaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRolePermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteRolePermissionsBoundaryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRolePolicy(_a0 *iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteRolePolicyInput) *iam.DeleteRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRolePolicyRequest(_a0 *iam.DeleteRolePolicyInput) (*request.Request, *iam.DeleteRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteRolePolicyInput) *iam.DeleteRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteRolePolicyOutput)
		}
	}

	return r0, r1
}

// DeleteRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteRolePolicyWithContext(_a0 context.Context, _a1 *iam.DeleteRolePolicyInput, _a2 ...request.Option) (*iam.DeleteRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteRolePolicyInput, ...request.Option) *iam.DeleteRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteRoleRequest(_a0 *iam.DeleteRoleInput) (*request.Request, *iam.DeleteRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteRoleInput) *iam.DeleteRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteRoleOutput)
		}
	}

	return r0, r1
}

// DeleteRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteRoleWithContext(_a0 context.Context, _a1 *iam.DeleteRoleInput, _a2 ...request.Option) (*iam.DeleteRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteRoleInput, ...request.Option) *iam.DeleteRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSAMLProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSAMLProvider(_a0 *iam.DeleteSAMLProviderInput) (*iam.DeleteSAMLProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteSAMLProviderInput) *iam.DeleteSAMLProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteSAMLProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSAMLProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSAMLProviderRequest(_a0 *iam.DeleteSAMLProviderInput) (*request.Request, *iam.DeleteSAMLProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteSAMLProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteSAMLProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteSAMLProviderInput) *iam.DeleteSAMLProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteSAMLProviderOutput)
		}
	}

	return r0, r1
}

// DeleteSAMLProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteSAMLProviderWithContext(_a0 context.Context, _a1 *iam.DeleteSAMLProviderInput, _a2 ...request.Option) (*iam.DeleteSAMLProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteSAMLProviderInput, ...request.Option) *iam.DeleteSAMLProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteSAMLProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSSHPublicKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSSHPublicKey(_a0 *iam.DeleteSSHPublicKeyInput) (*iam.DeleteSSHPublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteSSHPublicKeyInput) *iam.DeleteSSHPublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteSSHPublicKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSSHPublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSSHPublicKeyRequest(_a0 *iam.DeleteSSHPublicKeyInput) (*request.Request, *iam.DeleteSSHPublicKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteSSHPublicKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteSSHPublicKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteSSHPublicKeyInput) *iam.DeleteSSHPublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteSSHPublicKeyOutput)
		}
	}

	return r0, r1
}

// DeleteSSHPublicKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteSSHPublicKeyWithContext(_a0 context.Context, _a1 *iam.DeleteSSHPublicKeyInput, _a2 ...request.Option) (*iam.DeleteSSHPublicKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteSSHPublicKeyInput, ...request.Option) *iam.DeleteSSHPublicKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteSSHPublicKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServerCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServerCertificate(_a0 *iam.DeleteServerCertificateInput) (*iam.DeleteServerCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteServerCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteServerCertificateInput) *iam.DeleteServerCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteServerCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServerCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServerCertificateRequest(_a0 *iam.DeleteServerCertificateInput) (*request.Request, *iam.DeleteServerCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteServerCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteServerCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteServerCertificateInput) *iam.DeleteServerCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteServerCertificateOutput)
		}
	}

	return r0, r1
}

// DeleteServerCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteServerCertificateWithContext(_a0 context.Context, _a1 *iam.DeleteServerCertificateInput, _a2 ...request.Option) (*iam.DeleteServerCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteServerCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteServerCertificateInput, ...request.Option) *iam.DeleteServerCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteServerCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServiceLinkedRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServiceLinkedRole(_a0 *iam.DeleteServiceLinkedRoleInput) (*iam.DeleteServiceLinkedRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteServiceLinkedRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteServiceLinkedRoleInput) *iam.DeleteServiceLinkedRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServiceLinkedRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteServiceLinkedRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServiceLinkedRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServiceLinkedRoleRequest(_a0 *iam.DeleteServiceLinkedRoleInput) (*request.Request, *iam.DeleteServiceLinkedRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteServiceLinkedRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteServiceLinkedRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteServiceLinkedRoleInput) *iam.DeleteServiceLinkedRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteServiceLinkedRoleOutput)
		}
	}

	return r0, r1
}

// DeleteServiceLinkedRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteServiceLinkedRoleWithContext(_a0 context.Context, _a1 *iam.DeleteServiceLinkedRoleInput, _a2 ...request.Option) (*iam.DeleteServiceLinkedRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteServiceLinkedRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteServiceLinkedRoleInput, ...request.Option) *iam.DeleteServiceLinkedRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServiceLinkedRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteServiceLinkedRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServiceSpecificCredential provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServiceSpecificCredential(_a0 *iam.DeleteServiceSpecificCredentialInput) (*iam.DeleteServiceSpecificCredentialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteServiceSpecificCredentialInput) *iam.DeleteServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteServiceSpecificCredentialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteServiceSpecificCredentialRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteServiceSpecificCredentialRequest(_a0 *iam.DeleteServiceSpecificCredentialInput) (*request.Request, *iam.DeleteServiceSpecificCredentialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteServiceSpecificCredentialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteServiceSpecificCredentialOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteServiceSpecificCredentialInput) *iam.DeleteServiceSpecificCredentialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteServiceSpecificCredentialOutput)
		}
	}

	return r0, r1
}

// DeleteServiceSpecificCredentialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteServiceSpecificCredentialWithContext(_a0 context.Context, _a1 *iam.DeleteServiceSpecificCredentialInput, _a2 ...request.Option) (*iam.DeleteServiceSpecificCredentialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteServiceSpecificCredentialInput, ...request.Option) *iam.DeleteServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteServiceSpecificCredentialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSigningCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSigningCertificate(_a0 *iam.DeleteSigningCertificateInput) (*iam.DeleteSigningCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteSigningCertificateInput) *iam.DeleteSigningCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteSigningCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteSigningCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteSigningCertificateRequest(_a0 *iam.DeleteSigningCertificateInput) (*request.Request, *iam.DeleteSigningCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteSigningCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteSigningCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteSigningCertificateInput) *iam.DeleteSigningCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteSigningCertificateOutput)
		}
	}

	return r0, r1
}

// DeleteSigningCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteSigningCertificateWithContext(_a0 context.Context, _a1 *iam.DeleteSigningCertificateInput, _a2 ...request.Option) (*iam.DeleteSigningCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteSigningCertificateInput, ...request.Option) *iam.DeleteSigningCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteSigningCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUser(_a0 *iam.DeleteUserInput) (*iam.DeleteUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteUserOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserInput) *iam.DeleteUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserPermissionsBoundary provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUserPermissionsBoundary(_a0 *iam.DeleteUserPermissionsBoundaryInput) (*iam.DeleteUserPermissionsBoundaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserPermissionsBoundaryInput) *iam.DeleteUserPermissionsBoundaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserPermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserPermissionsBoundaryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserPermissionsBoundaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUserPermissionsBoundaryRequest(_a0 *iam.DeleteUserPermissionsBoundaryInput) (*request.Request, *iam.DeleteUserPermissionsBoundaryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserPermissionsBoundaryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserPermissionsBoundaryInput) *iam.DeleteUserPermissionsBoundaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteUserPermissionsBoundaryOutput)
		}
	}

	return r0, r1
}

// DeleteUserPermissionsBoundaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteUserPermissionsBoundaryWithContext(_a0 context.Context, _a1 *iam.DeleteUserPermissionsBoundaryInput, _a2 ...request.Option) (*iam.DeleteUserPermissionsBoundaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteUserPermissionsBoundaryInput, ...request.Option) *iam.DeleteUserPermissionsBoundaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserPermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteUserPermissionsBoundaryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUserPolicy(_a0 *iam.DeleteUserPolicyInput) (*iam.DeleteUserPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteUserPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserPolicyInput) *iam.DeleteUserPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUserPolicyRequest(_a0 *iam.DeleteUserPolicyInput) (*request.Request, *iam.DeleteUserPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteUserPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserPolicyInput) *iam.DeleteUserPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteUserPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteUserPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteUserPolicyWithContext(_a0 context.Context, _a1 *iam.DeleteUserPolicyInput, _a2 ...request.Option) (*iam.DeleteUserPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteUserPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteUserPolicyInput, ...request.Option) *iam.DeleteUserPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteUserPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteUserRequest(_a0 *iam.DeleteUserInput) (*request.Request, *iam.DeleteUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteUserOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteUserInput) *iam.DeleteUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteUserOutput)
		}
	}

	return r0, r1
}

// DeleteUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteUserWithContext(_a0 context.Context, _a1 *iam.DeleteUserInput, _a2 ...request.Option) (*iam.DeleteUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteUserInput, ...request.Option) *iam.DeleteUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteVirtualMFADevice provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteVirtualMFADevice(_a0 *iam.DeleteVirtualMFADeviceInput) (*iam.DeleteVirtualMFADeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DeleteVirtualMFADeviceOutput
	if rf, ok := ret.Get(0).(func(*iam.DeleteVirtualMFADeviceInput) *iam.DeleteVirtualMFADeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteVirtualMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DeleteVirtualMFADeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteVirtualMFADeviceRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DeleteVirtualMFADeviceRequest(_a0 *iam.DeleteVirtualMFADeviceInput) (*request.Request, *iam.DeleteVirtualMFADeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DeleteVirtualMFADeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DeleteVirtualMFADeviceOutput
	if rf, ok := ret.Get(1).(func(*iam.DeleteVirtualMFADeviceInput) *iam.DeleteVirtualMFADeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DeleteVirtualMFADeviceOutput)
		}
	}

	return r0, r1
}

// DeleteVirtualMFADeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DeleteVirtualMFADeviceWithContext(_a0 context.Context, _a1 *iam.DeleteVirtualMFADeviceInput, _a2 ...request.Option) (*iam.DeleteVirtualMFADeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DeleteVirtualMFADeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DeleteVirtualMFADeviceInput, ...request.Option) *iam.DeleteVirtualMFADeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DeleteVirtualMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DeleteVirtualMFADeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachGroupPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachGroupPolicy(_a0 *iam.DetachGroupPolicyInput) (*iam.DetachGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DetachGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DetachGroupPolicyInput) *iam.DetachGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DetachGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachGroupPolicyRequest(_a0 *iam.DetachGroupPolicyInput) (*request.Request, *iam.DetachGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DetachGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DetachGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DetachGroupPolicyInput) *iam.DetachGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DetachGroupPolicyOutput)
		}
	}

	return r0, r1
}

// DetachGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DetachGroupPolicyWithContext(_a0 context.Context, _a1 *iam.DetachGroupPolicyInput, _a2 ...request.Option) (*iam.DetachGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DetachGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DetachGroupPolicyInput, ...request.Option) *iam.DetachGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DetachGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachRolePolicy(_a0 *iam.DetachRolePolicyInput) (*iam.DetachRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DetachRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DetachRolePolicyInput) *iam.DetachRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DetachRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachRolePolicyRequest(_a0 *iam.DetachRolePolicyInput) (*request.Request, *iam.DetachRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DetachRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DetachRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DetachRolePolicyInput) *iam.DetachRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DetachRolePolicyOutput)
		}
	}

	return r0, r1
}

// DetachRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DetachRolePolicyWithContext(_a0 context.Context, _a1 *iam.DetachRolePolicyInput, _a2 ...request.Option) (*iam.DetachRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DetachRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DetachRolePolicyInput, ...request.Option) *iam.DetachRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DetachRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachUserPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachUserPolicy(_a0 *iam.DetachUserPolicyInput) (*iam.DetachUserPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.DetachUserPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.DetachUserPolicyInput) *iam.DetachUserPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.DetachUserPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DetachUserPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) DetachUserPolicyRequest(_a0 *iam.DetachUserPolicyInput) (*request.Request, *iam.DetachUserPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.DetachUserPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.DetachUserPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.DetachUserPolicyInput) *iam.DetachUserPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.DetachUserPolicyOutput)
		}
	}

	return r0, r1
}

// DetachUserPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) DetachUserPolicyWithContext(_a0 context.Context, _a1 *iam.DetachUserPolicyInput, _a2 ...request.Option) (*iam.DetachUserPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.DetachUserPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.DetachUserPolicyInput, ...request.Option) *iam.DetachUserPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.DetachUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.DetachUserPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableMFADevice provides a mock function with given fields: _a0
func (_m *MockFakeIAM) EnableMFADevice(_a0 *iam.EnableMFADeviceInput) (*iam.EnableMFADeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.EnableMFADeviceOutput
	if rf, ok := ret.Get(0).(func(*iam.EnableMFADeviceInput) *iam.EnableMFADeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.EnableMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.EnableMFADeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableMFADeviceRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) EnableMFADeviceRequest(_a0 *iam.EnableMFADeviceInput) (*request.Request, *iam.EnableMFADeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.EnableMFADeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.EnableMFADeviceOutput
	if rf, ok := ret.Get(1).(func(*iam.EnableMFADeviceInput) *iam.EnableMFADeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.EnableMFADeviceOutput)
		}
	}

	return r0, r1
}

// EnableMFADeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) EnableMFADeviceWithContext(_a0 context.Context, _a1 *iam.EnableMFADeviceInput, _a2 ...request.Option) (*iam.EnableMFADeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.EnableMFADeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.EnableMFADeviceInput, ...request.Option) *iam.EnableMFADeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.EnableMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.EnableMFADeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateCredentialReport provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateCredentialReport(_a0 *iam.GenerateCredentialReportInput) (*iam.GenerateCredentialReportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GenerateCredentialReportOutput
	if rf, ok := ret.Get(0).(func(*iam.GenerateCredentialReportInput) *iam.GenerateCredentialReportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateCredentialReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GenerateCredentialReportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateCredentialReportRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateCredentialReportRequest(_a0 *iam.GenerateCredentialReportInput) (*request.Request, *iam.GenerateCredentialReportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GenerateCredentialReportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GenerateCredentialReportOutput
	if rf, ok := ret.Get(1).(func(*iam.GenerateCredentialReportInput) *iam.GenerateCredentialReportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GenerateCredentialReportOutput)
		}
	}

	return r0, r1
}

// GenerateCredentialReportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GenerateCredentialReportWithContext(_a0 context.Context, _a1 *iam.GenerateCredentialReportInput, _a2 ...request.Option) (*iam.GenerateCredentialReportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GenerateCredentialReportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GenerateCredentialReportInput, ...request.Option) *iam.GenerateCredentialReportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateCredentialReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GenerateCredentialReportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateOrganizationsAccessReport provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateOrganizationsAccessReport(_a0 *iam.GenerateOrganizationsAccessReportInput) (*iam.GenerateOrganizationsAccessReportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GenerateOrganizationsAccessReportOutput
	if rf, ok := ret.Get(0).(func(*iam.GenerateOrganizationsAccessReportInput) *iam.GenerateOrganizationsAccessReportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateOrganizationsAccessReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GenerateOrganizationsAccessReportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateOrganizationsAccessReportRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateOrganizationsAccessReportRequest(_a0 *iam.GenerateOrganizationsAccessReportInput) (*request.Request, *iam.GenerateOrganizationsAccessReportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GenerateOrganizationsAccessReportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GenerateOrganizationsAccessReportOutput
	if rf, ok := ret.Get(1).(func(*iam.GenerateOrganizationsAccessReportInput) *iam.GenerateOrganizationsAccessReportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GenerateOrganizationsAccessReportOutput)
		}
	}

	return r0, r1
}

// GenerateOrganizationsAccessReportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GenerateOrganizationsAccessReportWithContext(_a0 context.Context, _a1 *iam.GenerateOrganizationsAccessReportInput, _a2 ...request.Option) (*iam.GenerateOrganizationsAccessReportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GenerateOrganizationsAccessReportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GenerateOrganizationsAccessReportInput, ...request.Option) *iam.GenerateOrganizationsAccessReportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateOrganizationsAccessReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GenerateOrganizationsAccessReportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateServiceLastAccessedDetails provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateServiceLastAccessedDetails(_a0 *iam.GenerateServiceLastAccessedDetailsInput) (*iam.GenerateServiceLastAccessedDetailsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GenerateServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(0).(func(*iam.GenerateServiceLastAccessedDetailsInput) *iam.GenerateServiceLastAccessedDetailsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateServiceLastAccessedDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GenerateServiceLastAccessedDetailsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GenerateServiceLastAccessedDetailsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GenerateServiceLastAccessedDetailsRequest(_a0 *iam.GenerateServiceLastAccessedDetailsInput) (*request.Request, *iam.GenerateServiceLastAccessedDetailsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GenerateServiceLastAccessedDetailsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GenerateServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(1).(func(*iam.GenerateServiceLastAccessedDetailsInput) *iam.GenerateServiceLastAccessedDetailsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GenerateServiceLastAccessedDetailsOutput)
		}
	}

	return r0, r1
}

// GenerateServiceLastAccessedDetailsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GenerateServiceLastAccessedDetailsWithContext(_a0 context.Context, _a1 *iam.GenerateServiceLastAccessedDetailsInput, _a2 ...request.Option) (*iam.GenerateServiceLastAccessedDetailsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GenerateServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GenerateServiceLastAccessedDetailsInput, ...request.Option) *iam.GenerateServiceLastAccessedDetailsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GenerateServiceLastAccessedDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GenerateServiceLastAccessedDetailsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccessKeyLastUsed provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccessKeyLastUsed(_a0 *iam.GetAccessKeyLastUsedInput) (*iam.GetAccessKeyLastUsedOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetAccessKeyLastUsedOutput
	if rf, ok := ret.Get(0).(func(*iam.GetAccessKeyLastUsedInput) *iam.GetAccessKeyLastUsedOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccessKeyLastUsedOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetAccessKeyLastUsedInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccessKeyLastUsedRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccessKeyLastUsedRequest(_a0 *iam.GetAccessKeyLastUsedInput) (*request.Request, *iam.GetAccessKeyLastUsedOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetAccessKeyLastUsedInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetAccessKeyLastUsedOutput
	if rf, ok := ret.Get(1).(func(*iam.GetAccessKeyLastUsedInput) *iam.GetAccessKeyLastUsedOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetAccessKeyLastUsedOutput)
		}
	}

	return r0, r1
}

// GetAccessKeyLastUsedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetAccessKeyLastUsedWithContext(_a0 context.Context, _a1 *iam.GetAccessKeyLastUsedInput, _a2 ...request.Option) (*iam.GetAccessKeyLastUsedOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetAccessKeyLastUsedOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetAccessKeyLastUsedInput, ...request.Option) *iam.GetAccessKeyLastUsedOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccessKeyLastUsedOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetAccessKeyLastUsedInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountAuthorizationDetails provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountAuthorizationDetails(_a0 *iam.GetAccountAuthorizationDetailsInput) (*iam.GetAccountAuthorizationDetailsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetAccountAuthorizationDetailsOutput
	if rf, ok := ret.Get(0).(func(*iam.GetAccountAuthorizationDetailsInput) *iam.GetAccountAuthorizationDetailsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountAuthorizationDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetAccountAuthorizationDetailsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountAuthorizationDetailsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) GetAccountAuthorizationDetailsPages(_a0 *iam.GetAccountAuthorizationDetailsInput, _a1 func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetAccountAuthorizationDetailsInput, func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAccountAuthorizationDetailsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) GetAccountAuthorizationDetailsPagesWithContext(_a0 context.Context, _a1 *iam.GetAccountAuthorizationDetailsInput, _a2 func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetAccountAuthorizationDetailsInput, func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAccountAuthorizationDetailsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountAuthorizationDetailsRequest(_a0 *iam.GetAccountAuthorizationDetailsInput) (*request.Request, *iam.GetAccountAuthorizationDetailsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetAccountAuthorizationDetailsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetAccountAuthorizationDetailsOutput
	if rf, ok := ret.Get(1).(func(*iam.GetAccountAuthorizationDetailsInput) *iam.GetAccountAuthorizationDetailsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetAccountAuthorizationDetailsOutput)
		}
	}

	return r0, r1
}

// GetAccountAuthorizationDetailsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetAccountAuthorizationDetailsWithContext(_a0 context.Context, _a1 *iam.GetAccountAuthorizationDetailsInput, _a2 ...request.Option) (*iam.GetAccountAuthorizationDetailsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetAccountAuthorizationDetailsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetAccountAuthorizationDetailsInput, ...request.Option) *iam.GetAccountAuthorizationDetailsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountAuthorizationDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetAccountAuthorizationDetailsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountPasswordPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountPasswordPolicy(_a0 *iam.GetAccountPasswordPolicyInput) (*iam.GetAccountPasswordPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetAccountPasswordPolicyInput) *iam.GetAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetAccountPasswordPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountPasswordPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountPasswordPolicyRequest(_a0 *iam.GetAccountPasswordPolicyInput) (*request.Request, *iam.GetAccountPasswordPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetAccountPasswordPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetAccountPasswordPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetAccountPasswordPolicyInput) *iam.GetAccountPasswordPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetAccountPasswordPolicyOutput)
		}
	}

	return r0, r1
}

// GetAccountPasswordPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetAccountPasswordPolicyWithContext(_a0 context.Context, _a1 *iam.GetAccountPasswordPolicyInput, _a2 ...request.Option) (*iam.GetAccountPasswordPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetAccountPasswordPolicyInput, ...request.Option) *iam.GetAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetAccountPasswordPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountSummary provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountSummary(_a0 *iam.GetAccountSummaryInput) (*iam.GetAccountSummaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetAccountSummaryOutput
	if rf, ok := ret.Get(0).(func(*iam.GetAccountSummaryInput) *iam.GetAccountSummaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountSummaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetAccountSummaryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetAccountSummaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetAccountSummaryRequest(_a0 *iam.GetAccountSummaryInput) (*request.Request, *iam.GetAccountSummaryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetAccountSummaryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetAccountSummaryOutput
	if rf, ok := ret.Get(1).(func(*iam.GetAccountSummaryInput) *iam.GetAccountSummaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetAccountSummaryOutput)
		}
	}

	return r0, r1
}

// GetAccountSummaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetAccountSummaryWithContext(_a0 context.Context, _a1 *iam.GetAccountSummaryInput, _a2 ...request.Option) (*iam.GetAccountSummaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetAccountSummaryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetAccountSummaryInput, ...request.Option) *iam.GetAccountSummaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetAccountSummaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetAccountSummaryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetContextKeysForCustomPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetContextKeysForCustomPolicy(_a0 *iam.GetContextKeysForCustomPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(0).(func(*iam.GetContextKeysForCustomPolicyInput) *iam.GetContextKeysForPolicyResponse); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetContextKeysForCustomPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetContextKeysForCustomPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetContextKeysForCustomPolicyRequest(_a0 *iam.GetContextKeysForCustomPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetContextKeysForCustomPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(1).(func(*iam.GetContextKeysForCustomPolicyInput) *iam.GetContextKeysForPolicyResponse); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	return r0, r1
}

// GetContextKeysForCustomPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetContextKeysForCustomPolicyWithContext(_a0 context.Context, _a1 *iam.GetContextKeysForCustomPolicyInput, _a2 ...request.Option) (*iam.GetContextKeysForPolicyResponse, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetContextKeysForCustomPolicyInput, ...request.Option) *iam.GetContextKeysForPolicyResponse); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetContextKeysForCustomPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetContextKeysForPrincipalPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetContextKeysForPrincipalPolicy(_a0 *iam.GetContextKeysForPrincipalPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(0).(func(*iam.GetContextKeysForPrincipalPolicyInput) *iam.GetContextKeysForPolicyResponse); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetContextKeysForPrincipalPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetContextKeysForPrincipalPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetContextKeysForPrincipalPolicyRequest(_a0 *iam.GetContextKeysForPrincipalPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetContextKeysForPrincipalPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(1).(func(*iam.GetContextKeysForPrincipalPolicyInput) *iam.GetContextKeysForPolicyResponse); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	return r0, r1
}

// GetContextKeysForPrincipalPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetContextKeysForPrincipalPolicyWithContext(_a0 context.Context, _a1 *iam.GetContextKeysForPrincipalPolicyInput, _a2 ...request.Option) (*iam.GetContextKeysForPolicyResponse, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetContextKeysForPolicyResponse
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetContextKeysForPrincipalPolicyInput, ...request.Option) *iam.GetContextKeysForPolicyResponse); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetContextKeysForPolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetContextKeysForPrincipalPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCredentialReport provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetCredentialReport(_a0 *iam.GetCredentialReportInput) (*iam.GetCredentialReportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetCredentialReportOutput
	if rf, ok := ret.Get(0).(func(*iam.GetCredentialReportInput) *iam.GetCredentialReportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetCredentialReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetCredentialReportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCredentialReportRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetCredentialReportRequest(_a0 *iam.GetCredentialReportInput) (*request.Request, *iam.GetCredentialReportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetCredentialReportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetCredentialReportOutput
	if rf, ok := ret.Get(1).(func(*iam.GetCredentialReportInput) *iam.GetCredentialReportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetCredentialReportOutput)
		}
	}

	return r0, r1
}

// GetCredentialReportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetCredentialReportWithContext(_a0 context.Context, _a1 *iam.GetCredentialReportInput, _a2 ...request.Option) (*iam.GetCredentialReportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetCredentialReportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetCredentialReportInput, ...request.Option) *iam.GetCredentialReportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetCredentialReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetCredentialReportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetGroup(_a0 *iam.GetGroupInput) (*iam.GetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.GetGroupInput) *iam.GetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroupPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) GetGroupPages(_a0 *iam.GetGroupInput, _a1 func(*iam.GetGroupOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetGroupInput, func(*iam.GetGroupOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetGroupPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) GetGroupPagesWithContext(_a0 context.Context, _a1 *iam.GetGroupInput, _a2 func(*iam.GetGroupOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetGroupInput, func(*iam.GetGroupOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetGroupPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetGroupPolicy(_a0 *iam.GetGroupPolicyInput) (*iam.GetGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetGroupPolicyInput) *iam.GetGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetGroupPolicyRequest(_a0 *iam.GetGroupPolicyInput) (*request.Request, *iam.GetGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetGroupPolicyInput) *iam.GetGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetGroupPolicyOutput)
		}
	}

	return r0, r1
}

// GetGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetGroupPolicyWithContext(_a0 context.Context, _a1 *iam.GetGroupPolicyInput, _a2 ...request.Option) (*iam.GetGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetGroupPolicyInput, ...request.Option) *iam.GetGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetGroupRequest(_a0 *iam.GetGroupInput) (*request.Request, *iam.GetGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.GetGroupInput) *iam.GetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetGroupOutput)
		}
	}

	return r0, r1
}

// GetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetGroupWithContext(_a0 context.Context, _a1 *iam.GetGroupInput, _a2 ...request.Option) (*iam.GetGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetGroupInput, ...request.Option) *iam.GetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetInstanceProfile(_a0 *iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.GetInstanceProfileInput) *iam.GetInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetInstanceProfileRequest(_a0 *iam.GetInstanceProfileInput) (*request.Request, *iam.GetInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.GetInstanceProfileInput) *iam.GetInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetInstanceProfileOutput)
		}
	}

	return r0, r1
}

// GetInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetInstanceProfileWithContext(_a0 context.Context, _a1 *iam.GetInstanceProfileInput, _a2 ...request.Option) (*iam.GetInstanceProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetInstanceProfileInput, ...request.Option) *iam.GetInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLoginProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetLoginProfile(_a0 *iam.GetLoginProfileInput) (*iam.GetLoginProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetLoginProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.GetLoginProfileInput) *iam.GetLoginProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetLoginProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetLoginProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetLoginProfileRequest(_a0 *iam.GetLoginProfileInput) (*request.Request, *iam.GetLoginProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetLoginProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetLoginProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.GetLoginProfileInput) *iam.GetLoginProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetLoginProfileOutput)
		}
	}

	return r0, r1
}

// GetLoginProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetLoginProfileWithContext(_a0 context.Context, _a1 *iam.GetLoginProfileInput, _a2 ...request.Option) (*iam.GetLoginProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetLoginProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetLoginProfileInput, ...request.Option) *iam.GetLoginProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetLoginProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOpenIDConnectProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetOpenIDConnectProvider(_a0 *iam.GetOpenIDConnectProviderInput) (*iam.GetOpenIDConnectProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.GetOpenIDConnectProviderInput) *iam.GetOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetOpenIDConnectProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOpenIDConnectProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetOpenIDConnectProviderRequest(_a0 *iam.GetOpenIDConnectProviderInput) (*request.Request, *iam.GetOpenIDConnectProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetOpenIDConnectProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetOpenIDConnectProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.GetOpenIDConnectProviderInput) *iam.GetOpenIDConnectProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetOpenIDConnectProviderOutput)
		}
	}

	return r0, r1
}

// GetOpenIDConnectProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetOpenIDConnectProviderWithContext(_a0 context.Context, _a1 *iam.GetOpenIDConnectProviderInput, _a2 ...request.Option) (*iam.GetOpenIDConnectProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOpenIDConnectProviderInput, ...request.Option) *iam.GetOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetOpenIDConnectProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOrganizationsAccessReport provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetOrganizationsAccessReport(_a0 *iam.GetOrganizationsAccessReportInput) (*iam.GetOrganizationsAccessReportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetOrganizationsAccessReportOutput
	if rf, ok := ret.Get(0).(func(*iam.GetOrganizationsAccessReportInput) *iam.GetOrganizationsAccessReportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetOrganizationsAccessReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetOrganizationsAccessReportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOrganizationsAccessReportRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetOrganizationsAccessReportRequest(_a0 *iam.GetOrganizationsAccessReportInput) (*request.Request, *iam.GetOrganizationsAccessReportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetOrganizationsAccessReportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetOrganizationsAccessReportOutput
	if rf, ok := ret.Get(1).(func(*iam.GetOrganizationsAccessReportInput) *iam.GetOrganizationsAccessReportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetOrganizationsAccessReportOutput)
		}
	}

	return r0, r1
}

// GetOrganizationsAccessReportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetOrganizationsAccessReportWithContext(_a0 context.Context, _a1 *iam.GetOrganizationsAccessReportInput, _a2 ...request.Option) (*iam.GetOrganizationsAccessReportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetOrganizationsAccessReportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...request.Option) *iam.GetOrganizationsAccessReportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetOrganizationsAccessReportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetOrganizationsAccessReportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetPolicy(_a0 *iam.GetPolicyInput) (*iam.GetPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetPolicyInput) *iam.GetPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetPolicyRequest(_a0 *iam.GetPolicyInput) (*request.Request, *iam.GetPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetPolicyInput) *iam.GetPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetPolicyOutput)
		}
	}

	return r0, r1
}

// GetPolicyVersion provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetPolicyVersion(_a0 *iam.GetPolicyVersionInput) (*iam.GetPolicyVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(*iam.GetPolicyVersionInput) *iam.GetPolicyVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetPolicyVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicyVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetPolicyVersionRequest(_a0 *iam.GetPolicyVersionInput) (*request.Request, *iam.GetPolicyVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetPolicyVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetPolicyVersionOutput
	if rf, ok := ret.Get(1).(func(*iam.GetPolicyVersionInput) *iam.GetPolicyVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetPolicyVersionOutput)
		}
	}

	return r0, r1
}

// GetPolicyVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetPolicyVersionWithContext(_a0 context.Context, _a1 *iam.GetPolicyVersionInput, _a2 ...request.Option) (*iam.GetPolicyVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetPolicyVersionInput, ...request.Option) *iam.GetPolicyVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetPolicyVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetPolicyWithContext(_a0 context.Context, _a1 *iam.GetPolicyInput, _a2 ...request.Option) (*iam.GetPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetPolicyInput, ...request.Option) *iam.GetPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetRole(_a0 *iam.GetRoleInput) (*iam.GetRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.GetRoleInput) *iam.GetRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetRolePolicy(_a0 *iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetRolePolicyInput) *iam.GetRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetRolePolicyRequest(_a0 *iam.GetRolePolicyInput) (*request.Request, *iam.GetRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetRolePolicyInput) *iam.GetRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetRolePolicyOutput)
		}
	}

	return r0, r1
}

// GetRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetRolePolicyWithContext(_a0 context.Context, _a1 *iam.GetRolePolicyInput, _a2 ...request.Option) (*iam.GetRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetRolePolicyInput, ...request.Option) *iam.GetRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetRoleRequest(_a0 *iam.GetRoleInput) (*request.Request, *iam.GetRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.GetRoleInput) *iam.GetRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetRoleOutput)
		}
	}

	return r0, r1
}

// GetRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetRoleWithContext(_a0 context.Context, _a1 *iam.GetRoleInput, _a2 ...request.Option) (*iam.GetRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetRoleInput, ...request.Option) *iam.GetRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSAMLProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetSAMLProvider(_a0 *iam.GetSAMLProviderInput) (*iam.GetSAMLProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.GetSAMLProviderInput) *iam.GetSAMLProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetSAMLProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSAMLProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetSAMLProviderRequest(_a0 *iam.GetSAMLProviderInput) (*request.Request, *iam.GetSAMLProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetSAMLProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetSAMLProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.GetSAMLProviderInput) *iam.GetSAMLProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetSAMLProviderOutput)
		}
	}

	return r0, r1
}

// GetSAMLProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetSAMLProviderWithContext(_a0 context.Context, _a1 *iam.GetSAMLProviderInput, _a2 ...request.Option) (*iam.GetSAMLProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetSAMLProviderInput, ...request.Option) *iam.GetSAMLProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetSAMLProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSSHPublicKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetSSHPublicKey(_a0 *iam.GetSSHPublicKeyInput) (*iam.GetSSHPublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetSSHPublicKeyInput) *iam.GetSSHPublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetSSHPublicKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSSHPublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetSSHPublicKeyRequest(_a0 *iam.GetSSHPublicKeyInput) (*request.Request, *iam.GetSSHPublicKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetSSHPublicKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetSSHPublicKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetSSHPublicKeyInput) *iam.GetSSHPublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetSSHPublicKeyOutput)
		}
	}

	return r0, r1
}

// GetSSHPublicKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetSSHPublicKeyWithContext(_a0 context.Context, _a1 *iam.GetSSHPublicKeyInput, _a2 ...request.Option) (*iam.GetSSHPublicKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetSSHPublicKeyInput, ...request.Option) *iam.GetSSHPublicKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetSSHPublicKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServerCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServerCertificate(_a0 *iam.GetServerCertificateInput) (*iam.GetServerCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetServerCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.GetServerCertificateInput) *iam.GetServerCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetServerCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServerCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServerCertificateRequest(_a0 *iam.GetServerCertificateInput) (*request.Request, *iam.GetServerCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetServerCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetServerCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.GetServerCertificateInput) *iam.GetServerCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetServerCertificateOutput)
		}
	}

	return r0, r1
}

// GetServerCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetServerCertificateWithContext(_a0 context.Context, _a1 *iam.GetServerCertificateInput, _a2 ...request.Option) (*iam.GetServerCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetServerCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetServerCertificateInput, ...request.Option) *iam.GetServerCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetServerCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLastAccessedDetails provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLastAccessedDetails(_a0 *iam.GetServiceLastAccessedDetailsInput) (*iam.GetServiceLastAccessedDetailsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLastAccessedDetailsInput) *iam.GetServiceLastAccessedDetailsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLastAccessedDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLastAccessedDetailsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLastAccessedDetailsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLastAccessedDetailsRequest(_a0 *iam.GetServiceLastAccessedDetailsInput) (*request.Request, *iam.GetServiceLastAccessedDetailsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLastAccessedDetailsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLastAccessedDetailsInput) *iam.GetServiceLastAccessedDetailsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetServiceLastAccessedDetailsOutput)
		}
	}

	return r0, r1
}

// GetServiceLastAccessedDetailsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetServiceLastAccessedDetailsWithContext(_a0 context.Context, _a1 *iam.GetServiceLastAccessedDetailsInput, _a2 ...request.Option) (*iam.GetServiceLastAccessedDetailsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetServiceLastAccessedDetailsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetServiceLastAccessedDetailsInput, ...request.Option) *iam.GetServiceLastAccessedDetailsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLastAccessedDetailsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetServiceLastAccessedDetailsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLastAccessedDetailsWithEntities provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLastAccessedDetailsWithEntities(_a0 *iam.GetServiceLastAccessedDetailsWithEntitiesInput) (*iam.GetServiceLastAccessedDetailsWithEntitiesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetServiceLastAccessedDetailsWithEntitiesOutput
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLastAccessedDetailsWithEntitiesInput) *iam.GetServiceLastAccessedDetailsWithEntitiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLastAccessedDetailsWithEntitiesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLastAccessedDetailsWithEntitiesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLastAccessedDetailsWithEntitiesRequest(_a0 *iam.GetServiceLastAccessedDetailsWithEntitiesInput) (*request.Request, *iam.GetServiceLastAccessedDetailsWithEntitiesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLastAccessedDetailsWithEntitiesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetServiceLastAccessedDetailsWithEntitiesOutput
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLastAccessedDetailsWithEntitiesInput) *iam.GetServiceLastAccessedDetailsWithEntitiesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput)
		}
	}

	return r0, r1
}

// GetServiceLastAccessedDetailsWithEntitiesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetServiceLastAccessedDetailsWithEntitiesWithContext(_a0 context.Context, _a1 *iam.GetServiceLastAccessedDetailsWithEntitiesInput, _a2 ...request.Option) (*iam.GetServiceLastAccessedDetailsWithEntitiesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetServiceLastAccessedDetailsWithEntitiesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetServiceLastAccessedDetailsWithEntitiesInput, ...request.Option) *iam.GetServiceLastAccessedDetailsWithEntitiesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetServiceLastAccessedDetailsWithEntitiesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLinkedRoleDeletionStatus provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLinkedRoleDeletionStatus(_a0 *iam.GetServiceLinkedRoleDeletionStatusInput) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetServiceLinkedRoleDeletionStatusOutput
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLinkedRoleDeletionStatusInput) *iam.GetServiceLinkedRoleDeletionStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLinkedRoleDeletionStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLinkedRoleDeletionStatusInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetServiceLinkedRoleDeletionStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetServiceLinkedRoleDeletionStatusRequest(_a0 *iam.GetServiceLinkedRoleDeletionStatusInput) (*request.Request, *iam.GetServiceLinkedRoleDeletionStatusOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetServiceLinkedRoleDeletionStatusInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetServiceLinkedRoleDeletionStatusOutput
	if rf, ok := ret.Get(1).(func(*iam.GetServiceLinkedRoleDeletionStatusInput) *iam.GetServiceLinkedRoleDeletionStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetServiceLinkedRoleDeletionStatusOutput)
		}
	}

	return r0, r1
}

// GetServiceLinkedRoleDeletionStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetServiceLinkedRoleDeletionStatusWithContext(_a0 context.Context, _a1 *iam.GetServiceLinkedRoleDeletionStatusInput, _a2 ...request.Option) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetServiceLinkedRoleDeletionStatusOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetServiceLinkedRoleDeletionStatusInput, ...request.Option) *iam.GetServiceLinkedRoleDeletionStatusOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetServiceLinkedRoleDeletionStatusOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetServiceLinkedRoleDeletionStatusInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetUser(_a0 *iam.GetUserInput) (*iam.GetUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetUserOutput
	if rf, ok := ret.Get(0).(func(*iam.GetUserInput) *iam.GetUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUserPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetUserPolicy(_a0 *iam.GetUserPolicyInput) (*iam.GetUserPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.GetUserPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.GetUserPolicyInput) *iam.GetUserPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.GetUserPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUserPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetUserPolicyRequest(_a0 *iam.GetUserPolicyInput) (*request.Request, *iam.GetUserPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetUserPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetUserPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.GetUserPolicyInput) *iam.GetUserPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetUserPolicyOutput)
		}
	}

	return r0, r1
}

// GetUserPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetUserPolicyWithContext(_a0 context.Context, _a1 *iam.GetUserPolicyInput, _a2 ...request.Option) (*iam.GetUserPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetUserPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetUserPolicyInput, ...request.Option) *iam.GetUserPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetUserPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) GetUserRequest(_a0 *iam.GetUserInput) (*request.Request, *iam.GetUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.GetUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.GetUserOutput
	if rf, ok := ret.Get(1).(func(*iam.GetUserInput) *iam.GetUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.GetUserOutput)
		}
	}

	return r0, r1
}

// GetUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) GetUserWithContext(_a0 context.Context, _a1 *iam.GetUserInput, _a2 ...request.Option) (*iam.GetUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.GetUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetUserInput, ...request.Option) *iam.GetUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.GetUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.GetUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAccessKeys provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAccessKeys(_a0 *iam.ListAccessKeysInput) (*iam.ListAccessKeysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListAccessKeysOutput
	if rf, ok := ret.Get(0).(func(*iam.ListAccessKeysInput) *iam.ListAccessKeysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAccessKeysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListAccessKeysInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAccessKeysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListAccessKeysPages(_a0 *iam.ListAccessKeysInput, _a1 func(*iam.ListAccessKeysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListAccessKeysInput, func(*iam.ListAccessKeysOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAccessKeysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListAccessKeysPagesWithContext(_a0 context.Context, _a1 *iam.ListAccessKeysInput, _a2 func(*iam.ListAccessKeysOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAccessKeysInput, func(*iam.ListAccessKeysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAccessKeysRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAccessKeysRequest(_a0 *iam.ListAccessKeysInput) (*request.Request, *iam.ListAccessKeysOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListAccessKeysInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListAccessKeysOutput
	if rf, ok := ret.Get(1).(func(*iam.ListAccessKeysInput) *iam.ListAccessKeysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListAccessKeysOutput)
		}
	}

	return r0, r1
}

// ListAccessKeysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListAccessKeysWithContext(_a0 context.Context, _a1 *iam.ListAccessKeysInput, _a2 ...request.Option) (*iam.ListAccessKeysOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListAccessKeysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAccessKeysInput, ...request.Option) *iam.ListAccessKeysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAccessKeysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListAccessKeysInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAccountAliases provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAccountAliases(_a0 *iam.ListAccountAliasesInput) (*iam.ListAccountAliasesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListAccountAliasesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListAccountAliasesInput) *iam.ListAccountAliasesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAccountAliasesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListAccountAliasesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAccountAliasesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListAccountAliasesPages(_a0 *iam.ListAccountAliasesInput, _a1 func(*iam.ListAccountAliasesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListAccountAliasesInput, func(*iam.ListAccountAliasesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAccountAliasesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListAccountAliasesPagesWithContext(_a0 context.Context, _a1 *iam.ListAccountAliasesInput, _a2 func(*iam.ListAccountAliasesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAccountAliasesInput, func(*iam.ListAccountAliasesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAccountAliasesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAccountAliasesRequest(_a0 *iam.ListAccountAliasesInput) (*request.Request, *iam.ListAccountAliasesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListAccountAliasesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListAccountAliasesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListAccountAliasesInput) *iam.ListAccountAliasesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListAccountAliasesOutput)
		}
	}

	return r0, r1
}

// ListAccountAliasesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListAccountAliasesWithContext(_a0 context.Context, _a1 *iam.ListAccountAliasesInput, _a2 ...request.Option) (*iam.ListAccountAliasesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListAccountAliasesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAccountAliasesInput, ...request.Option) *iam.ListAccountAliasesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAccountAliasesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListAccountAliasesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedGroupPolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedGroupPolicies(_a0 *iam.ListAttachedGroupPoliciesInput) (*iam.ListAttachedGroupPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListAttachedGroupPoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedGroupPoliciesInput) *iam.ListAttachedGroupPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedGroupPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedGroupPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedGroupPoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListAttachedGroupPoliciesPages(_a0 *iam.ListAttachedGroupPoliciesInput, _a1 func(*iam.ListAttachedGroupPoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedGroupPoliciesInput, func(*iam.ListAttachedGroupPoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedGroupPoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListAttachedGroupPoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListAttachedGroupPoliciesInput, _a2 func(*iam.ListAttachedGroupPoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedGroupPoliciesInput, func(*iam.ListAttachedGroupPoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedGroupPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedGroupPoliciesRequest(_a0 *iam.ListAttachedGroupPoliciesInput) (*request.Request, *iam.ListAttachedGroupPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedGroupPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListAttachedGroupPoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedGroupPoliciesInput) *iam.ListAttachedGroupPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListAttachedGroupPoliciesOutput)
		}
	}

	return r0, r1
}

// ListAttachedGroupPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListAttachedGroupPoliciesWithContext(_a0 context.Context, _a1 *iam.ListAttachedGroupPoliciesInput, _a2 ...request.Option) (*iam.ListAttachedGroupPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListAttachedGroupPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedGroupPoliciesInput, ...request.Option) *iam.ListAttachedGroupPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedGroupPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListAttachedGroupPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedRolePolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedRolePolicies(_a0 *iam.ListAttachedRolePoliciesInput) (*iam.ListAttachedRolePoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListAttachedRolePoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedRolePoliciesInput) *iam.ListAttachedRolePoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedRolePoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedRolePoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedRolePoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListAttachedRolePoliciesPages(_a0 *iam.ListAttachedRolePoliciesInput, _a1 func(*iam.ListAttachedRolePoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedRolePoliciesInput, func(*iam.ListAttachedRolePoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedRolePoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListAttachedRolePoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListAttachedRolePoliciesInput, _a2 func(*iam.ListAttachedRolePoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedRolePoliciesInput, func(*iam.ListAttachedRolePoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedRolePoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedRolePoliciesRequest(_a0 *iam.ListAttachedRolePoliciesInput) (*request.Request, *iam.ListAttachedRolePoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedRolePoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListAttachedRolePoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedRolePoliciesInput) *iam.ListAttachedRolePoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListAttachedRolePoliciesOutput)
		}
	}

	return r0, r1
}

// ListAttachedRolePoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListAttachedRolePoliciesWithContext(_a0 context.Context, _a1 *iam.ListAttachedRolePoliciesInput, _a2 ...request.Option) (*iam.ListAttachedRolePoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListAttachedRolePoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedRolePoliciesInput, ...request.Option) *iam.ListAttachedRolePoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedRolePoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListAttachedRolePoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedUserPolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedUserPolicies(_a0 *iam.ListAttachedUserPoliciesInput) (*iam.ListAttachedUserPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListAttachedUserPoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedUserPoliciesInput) *iam.ListAttachedUserPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedUserPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedUserPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAttachedUserPoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListAttachedUserPoliciesPages(_a0 *iam.ListAttachedUserPoliciesInput, _a1 func(*iam.ListAttachedUserPoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedUserPoliciesInput, func(*iam.ListAttachedUserPoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedUserPoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListAttachedUserPoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListAttachedUserPoliciesInput, _a2 func(*iam.ListAttachedUserPoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedUserPoliciesInput, func(*iam.ListAttachedUserPoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAttachedUserPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListAttachedUserPoliciesRequest(_a0 *iam.ListAttachedUserPoliciesInput) (*request.Request, *iam.ListAttachedUserPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListAttachedUserPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListAttachedUserPoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListAttachedUserPoliciesInput) *iam.ListAttachedUserPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListAttachedUserPoliciesOutput)
		}
	}

	return r0, r1
}

// ListAttachedUserPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListAttachedUserPoliciesWithContext(_a0 context.Context, _a1 *iam.ListAttachedUserPoliciesInput, _a2 ...request.Option) (*iam.ListAttachedUserPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListAttachedUserPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListAttachedUserPoliciesInput, ...request.Option) *iam.ListAttachedUserPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListAttachedUserPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListAttachedUserPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEntitiesForPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListEntitiesForPolicy(_a0 *iam.ListEntitiesForPolicyInput) (*iam.ListEntitiesForPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListEntitiesForPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.ListEntitiesForPolicyInput) *iam.ListEntitiesForPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListEntitiesForPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListEntitiesForPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEntitiesForPolicyPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListEntitiesForPolicyPages(_a0 *iam.ListEntitiesForPolicyInput, _a1 func(*iam.ListEntitiesForPolicyOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListEntitiesForPolicyInput, func(*iam.ListEntitiesForPolicyOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEntitiesForPolicyPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListEntitiesForPolicyPagesWithContext(_a0 context.Context, _a1 *iam.ListEntitiesForPolicyInput, _a2 func(*iam.ListEntitiesForPolicyOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListEntitiesForPolicyInput, func(*iam.ListEntitiesForPolicyOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListEntitiesForPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListEntitiesForPolicyRequest(_a0 *iam.ListEntitiesForPolicyInput) (*request.Request, *iam.ListEntitiesForPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListEntitiesForPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListEntitiesForPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.ListEntitiesForPolicyInput) *iam.ListEntitiesForPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListEntitiesForPolicyOutput)
		}
	}

	return r0, r1
}

// ListEntitiesForPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListEntitiesForPolicyWithContext(_a0 context.Context, _a1 *iam.ListEntitiesForPolicyInput, _a2 ...request.Option) (*iam.ListEntitiesForPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListEntitiesForPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListEntitiesForPolicyInput, ...request.Option) *iam.ListEntitiesForPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListEntitiesForPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListEntitiesForPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroupPolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroupPolicies(_a0 *iam.ListGroupPoliciesInput) (*iam.ListGroupPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListGroupPoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListGroupPoliciesInput) *iam.ListGroupPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListGroupPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroupPoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListGroupPoliciesPages(_a0 *iam.ListGroupPoliciesInput, _a1 func(*iam.ListGroupPoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListGroupPoliciesInput, func(*iam.ListGroupPoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupPoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListGroupPoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListGroupPoliciesInput, _a2 func(*iam.ListGroupPoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupPoliciesInput, func(*iam.ListGroupPoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroupPoliciesRequest(_a0 *iam.ListGroupPoliciesInput) (*request.Request, *iam.ListGroupPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListGroupPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListGroupPoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListGroupPoliciesInput) *iam.ListGroupPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListGroupPoliciesOutput)
		}
	}

	return r0, r1
}

// ListGroupPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListGroupPoliciesWithContext(_a0 context.Context, _a1 *iam.ListGroupPoliciesInput, _a2 ...request.Option) (*iam.ListGroupPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListGroupPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupPoliciesInput, ...request.Option) *iam.ListGroupPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListGroupPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroups provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroups(_a0 *iam.ListGroupsInput) (*iam.ListGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListGroupsOutput
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsInput) *iam.ListGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroupsForUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroupsForUser(_a0 *iam.ListGroupsForUserInput) (*iam.ListGroupsForUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListGroupsForUserOutput
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsForUserInput) *iam.ListGroupsForUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupsForUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListGroupsForUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroupsForUserPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListGroupsForUserPages(_a0 *iam.ListGroupsForUserInput, _a1 func(*iam.ListGroupsForUserOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsForUserInput, func(*iam.ListGroupsForUserOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupsForUserPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListGroupsForUserPagesWithContext(_a0 context.Context, _a1 *iam.ListGroupsForUserInput, _a2 func(*iam.ListGroupsForUserOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupsForUserInput, func(*iam.ListGroupsForUserOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupsForUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroupsForUserRequest(_a0 *iam.ListGroupsForUserInput) (*request.Request, *iam.ListGroupsForUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsForUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListGroupsForUserOutput
	if rf, ok := ret.Get(1).(func(*iam.ListGroupsForUserInput) *iam.ListGroupsForUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListGroupsForUserOutput)
		}
	}

	return r0, r1
}

// ListGroupsForUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListGroupsForUserWithContext(_a0 context.Context, _a1 *iam.ListGroupsForUserInput, _a2 ...request.Option) (*iam.ListGroupsForUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListGroupsForUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupsForUserInput, ...request.Option) *iam.ListGroupsForUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupsForUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListGroupsForUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListGroupsPages(_a0 *iam.ListGroupsInput, _a1 func(*iam.ListGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsInput, func(*iam.ListGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListGroupsPagesWithContext(_a0 context.Context, _a1 *iam.ListGroupsInput, _a2 func(*iam.ListGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupsInput, func(*iam.ListGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListGroupsRequest(_a0 *iam.ListGroupsInput) (*request.Request, *iam.ListGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListGroupsOutput
	if rf, ok := ret.Get(1).(func(*iam.ListGroupsInput) *iam.ListGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListGroupsOutput)
		}
	}

	return r0, r1
}

// ListGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListGroupsWithContext(_a0 context.Context, _a1 *iam.ListGroupsInput, _a2 ...request.Option) (*iam.ListGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListGroupsInput, ...request.Option) *iam.ListGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListInstanceProfiles provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListInstanceProfiles(_a0 *iam.ListInstanceProfilesInput) (*iam.ListInstanceProfilesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListInstanceProfilesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesInput) *iam.ListInstanceProfilesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListInstanceProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListInstanceProfilesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListInstanceProfilesForRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListInstanceProfilesForRole(_a0 *iam.ListInstanceProfilesForRoleInput) (*iam.ListInstanceProfilesForRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListInstanceProfilesForRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesForRoleInput) *iam.ListInstanceProfilesForRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListInstanceProfilesForRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListInstanceProfilesForRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListInstanceProfilesForRolePages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListInstanceProfilesForRolePages(_a0 *iam.ListInstanceProfilesForRoleInput, _a1 func(*iam.ListInstanceProfilesForRoleOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesForRoleInput, func(*iam.ListInstanceProfilesForRoleOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListInstanceProfilesForRolePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListInstanceProfilesForRolePagesWithContext(_a0 context.Context, _a1 *iam.ListInstanceProfilesForRoleInput, _a2 func(*iam.ListInstanceProfilesForRoleOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListInstanceProfilesForRoleInput, func(*iam.ListInstanceProfilesForRoleOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListInstanceProfilesForRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListInstanceProfilesForRoleRequest(_a0 *iam.ListInstanceProfilesForRoleInput) (*request.Request, *iam.ListInstanceProfilesForRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesForRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListInstanceProfilesForRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.ListInstanceProfilesForRoleInput) *iam.ListInstanceProfilesForRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListInstanceProfilesForRoleOutput)
		}
	}

	return r0, r1
}

// ListInstanceProfilesForRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListInstanceProfilesForRoleWithContext(_a0 context.Context, _a1 *iam.ListInstanceProfilesForRoleInput, _a2 ...request.Option) (*iam.ListInstanceProfilesForRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListInstanceProfilesForRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListInstanceProfilesForRoleInput, ...request.Option) *iam.ListInstanceProfilesForRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListInstanceProfilesForRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListInstanceProfilesForRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListInstanceProfilesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListInstanceProfilesPages(_a0 *iam.ListInstanceProfilesInput, _a1 func(*iam.ListInstanceProfilesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesInput, func(*iam.ListInstanceProfilesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListInstanceProfilesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListInstanceProfilesPagesWithContext(_a0 context.Context, _a1 *iam.ListInstanceProfilesInput, _a2 func(*iam.ListInstanceProfilesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListInstanceProfilesInput, func(*iam.ListInstanceProfilesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListInstanceProfilesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListInstanceProfilesRequest(_a0 *iam.ListInstanceProfilesInput) (*request.Request, *iam.ListInstanceProfilesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListInstanceProfilesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListInstanceProfilesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListInstanceProfilesInput) *iam.ListInstanceProfilesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListInstanceProfilesOutput)
		}
	}

	return r0, r1
}

// ListInstanceProfilesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListInstanceProfilesWithContext(_a0 context.Context, _a1 *iam.ListInstanceProfilesInput, _a2 ...request.Option) (*iam.ListInstanceProfilesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListInstanceProfilesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListInstanceProfilesInput, ...request.Option) *iam.ListInstanceProfilesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListInstanceProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListInstanceProfilesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMFADevices provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListMFADevices(_a0 *iam.ListMFADevicesInput) (*iam.ListMFADevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListMFADevicesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListMFADevicesInput) *iam.ListMFADevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListMFADevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListMFADevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListMFADevicesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListMFADevicesPages(_a0 *iam.ListMFADevicesInput, _a1 func(*iam.ListMFADevicesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListMFADevicesInput, func(*iam.ListMFADevicesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMFADevicesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListMFADevicesPagesWithContext(_a0 context.Context, _a1 *iam.ListMFADevicesInput, _a2 func(*iam.ListMFADevicesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListMFADevicesInput, func(*iam.ListMFADevicesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListMFADevicesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListMFADevicesRequest(_a0 *iam.ListMFADevicesInput) (*request.Request, *iam.ListMFADevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListMFADevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListMFADevicesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListMFADevicesInput) *iam.ListMFADevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListMFADevicesOutput)
		}
	}

	return r0, r1
}

// ListMFADevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListMFADevicesWithContext(_a0 context.Context, _a1 *iam.ListMFADevicesInput, _a2 ...request.Option) (*iam.ListMFADevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListMFADevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListMFADevicesInput, ...request.Option) *iam.ListMFADevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListMFADevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListMFADevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListOpenIDConnectProviders provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListOpenIDConnectProviders(_a0 *iam.ListOpenIDConnectProvidersInput) (*iam.ListOpenIDConnectProvidersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListOpenIDConnectProvidersOutput
	if rf, ok := ret.Get(0).(func(*iam.ListOpenIDConnectProvidersInput) *iam.ListOpenIDConnectProvidersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListOpenIDConnectProvidersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListOpenIDConnectProvidersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListOpenIDConnectProvidersRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListOpenIDConnectProvidersRequest(_a0 *iam.ListOpenIDConnectProvidersInput) (*request.Request, *iam.ListOpenIDConnectProvidersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListOpenIDConnectProvidersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListOpenIDConnectProvidersOutput
	if rf, ok := ret.Get(1).(func(*iam.ListOpenIDConnectProvidersInput) *iam.ListOpenIDConnectProvidersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListOpenIDConnectProvidersOutput)
		}
	}

	return r0, r1
}

// ListOpenIDConnectProvidersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListOpenIDConnectProvidersWithContext(_a0 context.Context, _a1 *iam.ListOpenIDConnectProvidersInput, _a2 ...request.Option) (*iam.ListOpenIDConnectProvidersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListOpenIDConnectProvidersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListOpenIDConnectProvidersInput, ...request.Option) *iam.ListOpenIDConnectProvidersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListOpenIDConnectProvidersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListOpenIDConnectProvidersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPolicies(_a0 *iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListPoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListPoliciesInput) *iam.ListPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPoliciesGrantingServiceAccess provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPoliciesGrantingServiceAccess(_a0 *iam.ListPoliciesGrantingServiceAccessInput) (*iam.ListPoliciesGrantingServiceAccessOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListPoliciesGrantingServiceAccessOutput
	if rf, ok := ret.Get(0).(func(*iam.ListPoliciesGrantingServiceAccessInput) *iam.ListPoliciesGrantingServiceAccessOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPoliciesGrantingServiceAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListPoliciesGrantingServiceAccessInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPoliciesGrantingServiceAccessRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPoliciesGrantingServiceAccessRequest(_a0 *iam.ListPoliciesGrantingServiceAccessInput) (*request.Request, *iam.ListPoliciesGrantingServiceAccessOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListPoliciesGrantingServiceAccessInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListPoliciesGrantingServiceAccessOutput
	if rf, ok := ret.Get(1).(func(*iam.ListPoliciesGrantingServiceAccessInput) *iam.ListPoliciesGrantingServiceAccessOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListPoliciesGrantingServiceAccessOutput)
		}
	}

	return r0, r1
}

// ListPoliciesGrantingServiceAccessWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListPoliciesGrantingServiceAccessWithContext(_a0 context.Context, _a1 *iam.ListPoliciesGrantingServiceAccessInput, _a2 ...request.Option) (*iam.ListPoliciesGrantingServiceAccessOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListPoliciesGrantingServiceAccessOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListPoliciesGrantingServiceAccessInput, ...request.Option) *iam.ListPoliciesGrantingServiceAccessOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPoliciesGrantingServiceAccessOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListPoliciesGrantingServiceAccessInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListPoliciesPages(_a0 *iam.ListPoliciesInput, _a1 func(*iam.ListPoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListPoliciesInput, func(*iam.ListPoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListPoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListPoliciesInput, _a2 func(*iam.ListPoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListPoliciesInput, func(*iam.ListPoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPoliciesRequest(_a0 *iam.ListPoliciesInput) (*request.Request, *iam.ListPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListPoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListPoliciesInput) *iam.ListPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListPoliciesOutput)
		}
	}

	return r0, r1
}

// ListPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListPoliciesWithContext(_a0 context.Context, _a1 *iam.ListPoliciesInput, _a2 ...request.Option) (*iam.ListPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListPoliciesInput, ...request.Option) *iam.ListPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPolicyVersions provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPolicyVersions(_a0 *iam.ListPolicyVersionsInput) (*iam.ListPolicyVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListPolicyVersionsOutput
	if rf, ok := ret.Get(0).(func(*iam.ListPolicyVersionsInput) *iam.ListPolicyVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPolicyVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListPolicyVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPolicyVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListPolicyVersionsPages(_a0 *iam.ListPolicyVersionsInput, _a1 func(*iam.ListPolicyVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListPolicyVersionsInput, func(*iam.ListPolicyVersionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPolicyVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListPolicyVersionsPagesWithContext(_a0 context.Context, _a1 *iam.ListPolicyVersionsInput, _a2 func(*iam.ListPolicyVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListPolicyVersionsInput, func(*iam.ListPolicyVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListPolicyVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListPolicyVersionsRequest(_a0 *iam.ListPolicyVersionsInput) (*request.Request, *iam.ListPolicyVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListPolicyVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListPolicyVersionsOutput
	if rf, ok := ret.Get(1).(func(*iam.ListPolicyVersionsInput) *iam.ListPolicyVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListPolicyVersionsOutput)
		}
	}

	return r0, r1
}

// ListPolicyVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListPolicyVersionsWithContext(_a0 context.Context, _a1 *iam.ListPolicyVersionsInput, _a2 ...request.Option) (*iam.ListPolicyVersionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListPolicyVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListPolicyVersionsInput, ...request.Option) *iam.ListPolicyVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListPolicyVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListPolicyVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRolePolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRolePolicies(_a0 *iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListRolePoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListRolePoliciesInput) *iam.ListRolePoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRolePoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListRolePoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRolePoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListRolePoliciesPages(_a0 *iam.ListRolePoliciesInput, _a1 func(*iam.ListRolePoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListRolePoliciesInput, func(*iam.ListRolePoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListRolePoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListRolePoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListRolePoliciesInput, _a2 func(*iam.ListRolePoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListRolePoliciesInput, func(*iam.ListRolePoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListRolePoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRolePoliciesRequest(_a0 *iam.ListRolePoliciesInput) (*request.Request, *iam.ListRolePoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListRolePoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListRolePoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListRolePoliciesInput) *iam.ListRolePoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListRolePoliciesOutput)
		}
	}

	return r0, r1
}

// ListRolePoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListRolePoliciesWithContext(_a0 context.Context, _a1 *iam.ListRolePoliciesInput, _a2 ...request.Option) (*iam.ListRolePoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListRolePoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListRolePoliciesInput, ...request.Option) *iam.ListRolePoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRolePoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListRolePoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRoleTags provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRoleTags(_a0 *iam.ListRoleTagsInput) (*iam.ListRoleTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListRoleTagsOutput
	if rf, ok := ret.Get(0).(func(*iam.ListRoleTagsInput) *iam.ListRoleTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRoleTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListRoleTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRoleTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRoleTagsRequest(_a0 *iam.ListRoleTagsInput) (*request.Request, *iam.ListRoleTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListRoleTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListRoleTagsOutput
	if rf, ok := ret.Get(1).(func(*iam.ListRoleTagsInput) *iam.ListRoleTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListRoleTagsOutput)
		}
	}

	return r0, r1
}

// ListRoleTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListRoleTagsWithContext(_a0 context.Context, _a1 *iam.ListRoleTagsInput, _a2 ...request.Option) (*iam.ListRoleTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListRoleTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListRoleTagsInput, ...request.Option) *iam.ListRoleTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRoleTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListRoleTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRoles provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRoles(_a0 *iam.ListRolesInput) (*iam.ListRolesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListRolesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListRolesInput) *iam.ListRolesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRolesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListRolesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRolesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListRolesPages(_a0 *iam.ListRolesInput, _a1 func(*iam.ListRolesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListRolesInput, func(*iam.ListRolesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListRolesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListRolesPagesWithContext(_a0 context.Context, _a1 *iam.ListRolesInput, _a2 func(*iam.ListRolesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListRolesInput, func(*iam.ListRolesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListRolesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListRolesRequest(_a0 *iam.ListRolesInput) (*request.Request, *iam.ListRolesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListRolesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListRolesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListRolesInput) *iam.ListRolesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListRolesOutput)
		}
	}

	return r0, r1
}

// ListRolesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListRolesWithContext(_a0 context.Context, _a1 *iam.ListRolesInput, _a2 ...request.Option) (*iam.ListRolesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListRolesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListRolesInput, ...request.Option) *iam.ListRolesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListRolesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListRolesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSAMLProviders provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSAMLProviders(_a0 *iam.ListSAMLProvidersInput) (*iam.ListSAMLProvidersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListSAMLProvidersOutput
	if rf, ok := ret.Get(0).(func(*iam.ListSAMLProvidersInput) *iam.ListSAMLProvidersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSAMLProvidersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListSAMLProvidersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSAMLProvidersRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSAMLProvidersRequest(_a0 *iam.ListSAMLProvidersInput) (*request.Request, *iam.ListSAMLProvidersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListSAMLProvidersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListSAMLProvidersOutput
	if rf, ok := ret.Get(1).(func(*iam.ListSAMLProvidersInput) *iam.ListSAMLProvidersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListSAMLProvidersOutput)
		}
	}

	return r0, r1
}

// ListSAMLProvidersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListSAMLProvidersWithContext(_a0 context.Context, _a1 *iam.ListSAMLProvidersInput, _a2 ...request.Option) (*iam.ListSAMLProvidersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListSAMLProvidersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListSAMLProvidersInput, ...request.Option) *iam.ListSAMLProvidersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSAMLProvidersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListSAMLProvidersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSSHPublicKeys provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSSHPublicKeys(_a0 *iam.ListSSHPublicKeysInput) (*iam.ListSSHPublicKeysOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListSSHPublicKeysOutput
	if rf, ok := ret.Get(0).(func(*iam.ListSSHPublicKeysInput) *iam.ListSSHPublicKeysOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSSHPublicKeysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListSSHPublicKeysInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSSHPublicKeysPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListSSHPublicKeysPages(_a0 *iam.ListSSHPublicKeysInput, _a1 func(*iam.ListSSHPublicKeysOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListSSHPublicKeysInput, func(*iam.ListSSHPublicKeysOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSSHPublicKeysPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListSSHPublicKeysPagesWithContext(_a0 context.Context, _a1 *iam.ListSSHPublicKeysInput, _a2 func(*iam.ListSSHPublicKeysOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListSSHPublicKeysInput, func(*iam.ListSSHPublicKeysOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSSHPublicKeysRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSSHPublicKeysRequest(_a0 *iam.ListSSHPublicKeysInput) (*request.Request, *iam.ListSSHPublicKeysOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListSSHPublicKeysInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListSSHPublicKeysOutput
	if rf, ok := ret.Get(1).(func(*iam.ListSSHPublicKeysInput) *iam.ListSSHPublicKeysOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListSSHPublicKeysOutput)
		}
	}

	return r0, r1
}

// ListSSHPublicKeysWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListSSHPublicKeysWithContext(_a0 context.Context, _a1 *iam.ListSSHPublicKeysInput, _a2 ...request.Option) (*iam.ListSSHPublicKeysOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListSSHPublicKeysOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListSSHPublicKeysInput, ...request.Option) *iam.ListSSHPublicKeysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSSHPublicKeysOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListSSHPublicKeysInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServerCertificates provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListServerCertificates(_a0 *iam.ListServerCertificatesInput) (*iam.ListServerCertificatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListServerCertificatesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListServerCertificatesInput) *iam.ListServerCertificatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListServerCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListServerCertificatesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServerCertificatesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListServerCertificatesPages(_a0 *iam.ListServerCertificatesInput, _a1 func(*iam.ListServerCertificatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListServerCertificatesInput, func(*iam.ListServerCertificatesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListServerCertificatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListServerCertificatesPagesWithContext(_a0 context.Context, _a1 *iam.ListServerCertificatesInput, _a2 func(*iam.ListServerCertificatesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListServerCertificatesInput, func(*iam.ListServerCertificatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListServerCertificatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListServerCertificatesRequest(_a0 *iam.ListServerCertificatesInput) (*request.Request, *iam.ListServerCertificatesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListServerCertificatesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListServerCertificatesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListServerCertificatesInput) *iam.ListServerCertificatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListServerCertificatesOutput)
		}
	}

	return r0, r1
}

// ListServerCertificatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListServerCertificatesWithContext(_a0 context.Context, _a1 *iam.ListServerCertificatesInput, _a2 ...request.Option) (*iam.ListServerCertificatesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListServerCertificatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListServerCertificatesInput, ...request.Option) *iam.ListServerCertificatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListServerCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListServerCertificatesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServiceSpecificCredentials provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListServiceSpecificCredentials(_a0 *iam.ListServiceSpecificCredentialsInput) (*iam.ListServiceSpecificCredentialsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListServiceSpecificCredentialsOutput
	if rf, ok := ret.Get(0).(func(*iam.ListServiceSpecificCredentialsInput) *iam.ListServiceSpecificCredentialsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListServiceSpecificCredentialsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListServiceSpecificCredentialsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListServiceSpecificCredentialsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListServiceSpecificCredentialsRequest(_a0 *iam.ListServiceSpecificCredentialsInput) (*request.Request, *iam.ListServiceSpecificCredentialsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListServiceSpecificCredentialsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListServiceSpecificCredentialsOutput
	if rf, ok := ret.Get(1).(func(*iam.ListServiceSpecificCredentialsInput) *iam.ListServiceSpecificCredentialsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListServiceSpecificCredentialsOutput)
		}
	}

	return r0, r1
}

// ListServiceSpecificCredentialsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListServiceSpecificCredentialsWithContext(_a0 context.Context, _a1 *iam.ListServiceSpecificCredentialsInput, _a2 ...request.Option) (*iam.ListServiceSpecificCredentialsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListServiceSpecificCredentialsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListServiceSpecificCredentialsInput, ...request.Option) *iam.ListServiceSpecificCredentialsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListServiceSpecificCredentialsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListServiceSpecificCredentialsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSigningCertificates provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSigningCertificates(_a0 *iam.ListSigningCertificatesInput) (*iam.ListSigningCertificatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListSigningCertificatesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListSigningCertificatesInput) *iam.ListSigningCertificatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSigningCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListSigningCertificatesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListSigningCertificatesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListSigningCertificatesPages(_a0 *iam.ListSigningCertificatesInput, _a1 func(*iam.ListSigningCertificatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListSigningCertificatesInput, func(*iam.ListSigningCertificatesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSigningCertificatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListSigningCertificatesPagesWithContext(_a0 context.Context, _a1 *iam.ListSigningCertificatesInput, _a2 func(*iam.ListSigningCertificatesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListSigningCertificatesInput, func(*iam.ListSigningCertificatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListSigningCertificatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListSigningCertificatesRequest(_a0 *iam.ListSigningCertificatesInput) (*request.Request, *iam.ListSigningCertificatesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListSigningCertificatesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListSigningCertificatesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListSigningCertificatesInput) *iam.ListSigningCertificatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListSigningCertificatesOutput)
		}
	}

	return r0, r1
}

// ListSigningCertificatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListSigningCertificatesWithContext(_a0 context.Context, _a1 *iam.ListSigningCertificatesInput, _a2 ...request.Option) (*iam.ListSigningCertificatesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListSigningCertificatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListSigningCertificatesInput, ...request.Option) *iam.ListSigningCertificatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListSigningCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListSigningCertificatesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserPolicies provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUserPolicies(_a0 *iam.ListUserPoliciesInput) (*iam.ListUserPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListUserPoliciesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListUserPoliciesInput) *iam.ListUserPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUserPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListUserPoliciesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserPoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListUserPoliciesPages(_a0 *iam.ListUserPoliciesInput, _a1 func(*iam.ListUserPoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListUserPoliciesInput, func(*iam.ListUserPoliciesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUserPoliciesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListUserPoliciesPagesWithContext(_a0 context.Context, _a1 *iam.ListUserPoliciesInput, _a2 func(*iam.ListUserPoliciesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListUserPoliciesInput, func(*iam.ListUserPoliciesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUserPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUserPoliciesRequest(_a0 *iam.ListUserPoliciesInput) (*request.Request, *iam.ListUserPoliciesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListUserPoliciesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListUserPoliciesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListUserPoliciesInput) *iam.ListUserPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListUserPoliciesOutput)
		}
	}

	return r0, r1
}

// ListUserPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListUserPoliciesWithContext(_a0 context.Context, _a1 *iam.ListUserPoliciesInput, _a2 ...request.Option) (*iam.ListUserPoliciesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListUserPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListUserPoliciesInput, ...request.Option) *iam.ListUserPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUserPoliciesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListUserPoliciesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserTags provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUserTags(_a0 *iam.ListUserTagsInput) (*iam.ListUserTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListUserTagsOutput
	if rf, ok := ret.Get(0).(func(*iam.ListUserTagsInput) *iam.ListUserTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUserTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListUserTagsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUserTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUserTagsRequest(_a0 *iam.ListUserTagsInput) (*request.Request, *iam.ListUserTagsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListUserTagsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListUserTagsOutput
	if rf, ok := ret.Get(1).(func(*iam.ListUserTagsInput) *iam.ListUserTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListUserTagsOutput)
		}
	}

	return r0, r1
}

// ListUserTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListUserTagsWithContext(_a0 context.Context, _a1 *iam.ListUserTagsInput, _a2 ...request.Option) (*iam.ListUserTagsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListUserTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListUserTagsInput, ...request.Option) *iam.ListUserTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUserTagsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListUserTagsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUsers provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUsers(_a0 *iam.ListUsersInput) (*iam.ListUsersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListUsersOutput
	if rf, ok := ret.Get(0).(func(*iam.ListUsersInput) *iam.ListUsersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUsersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListUsersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUsersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListUsersPages(_a0 *iam.ListUsersInput, _a1 func(*iam.ListUsersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListUsersInput, func(*iam.ListUsersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUsersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListUsersPagesWithContext(_a0 context.Context, _a1 *iam.ListUsersInput, _a2 func(*iam.ListUsersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListUsersInput, func(*iam.ListUsersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUsersRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListUsersRequest(_a0 *iam.ListUsersInput) (*request.Request, *iam.ListUsersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListUsersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListUsersOutput
	if rf, ok := ret.Get(1).(func(*iam.ListUsersInput) *iam.ListUsersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListUsersOutput)
		}
	}

	return r0, r1
}

// ListUsersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListUsersWithContext(_a0 context.Context, _a1 *iam.ListUsersInput, _a2 ...request.Option) (*iam.ListUsersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListUsersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListUsersInput, ...request.Option) *iam.ListUsersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListUsersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListUsersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVirtualMFADevices provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListVirtualMFADevices(_a0 *iam.ListVirtualMFADevicesInput) (*iam.ListVirtualMFADevicesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ListVirtualMFADevicesOutput
	if rf, ok := ret.Get(0).(func(*iam.ListVirtualMFADevicesInput) *iam.ListVirtualMFADevicesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListVirtualMFADevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ListVirtualMFADevicesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListVirtualMFADevicesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) ListVirtualMFADevicesPages(_a0 *iam.ListVirtualMFADevicesInput, _a1 func(*iam.ListVirtualMFADevicesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.ListVirtualMFADevicesInput, func(*iam.ListVirtualMFADevicesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListVirtualMFADevicesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) ListVirtualMFADevicesPagesWithContext(_a0 context.Context, _a1 *iam.ListVirtualMFADevicesInput, _a2 func(*iam.ListVirtualMFADevicesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListVirtualMFADevicesInput, func(*iam.ListVirtualMFADevicesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListVirtualMFADevicesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ListVirtualMFADevicesRequest(_a0 *iam.ListVirtualMFADevicesInput) (*request.Request, *iam.ListVirtualMFADevicesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ListVirtualMFADevicesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ListVirtualMFADevicesOutput
	if rf, ok := ret.Get(1).(func(*iam.ListVirtualMFADevicesInput) *iam.ListVirtualMFADevicesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ListVirtualMFADevicesOutput)
		}
	}

	return r0, r1
}

// ListVirtualMFADevicesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ListVirtualMFADevicesWithContext(_a0 context.Context, _a1 *iam.ListVirtualMFADevicesInput, _a2 ...request.Option) (*iam.ListVirtualMFADevicesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ListVirtualMFADevicesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ListVirtualMFADevicesInput, ...request.Option) *iam.ListVirtualMFADevicesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ListVirtualMFADevicesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ListVirtualMFADevicesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutGroupPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutGroupPolicy(_a0 *iam.PutGroupPolicyInput) (*iam.PutGroupPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.PutGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.PutGroupPolicyInput) *iam.PutGroupPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.PutGroupPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutGroupPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutGroupPolicyRequest(_a0 *iam.PutGroupPolicyInput) (*request.Request, *iam.PutGroupPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.PutGroupPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.PutGroupPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.PutGroupPolicyInput) *iam.PutGroupPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.PutGroupPolicyOutput)
		}
	}

	return r0, r1
}

// PutGroupPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) PutGroupPolicyWithContext(_a0 context.Context, _a1 *iam.PutGroupPolicyInput, _a2 ...request.Option) (*iam.PutGroupPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.PutGroupPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.PutGroupPolicyInput, ...request.Option) *iam.PutGroupPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutGroupPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.PutGroupPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRolePermissionsBoundary provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutRolePermissionsBoundary(_a0 *iam.PutRolePermissionsBoundaryInput) (*iam.PutRolePermissionsBoundaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.PutRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(*iam.PutRolePermissionsBoundaryInput) *iam.PutRolePermissionsBoundaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutRolePermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.PutRolePermissionsBoundaryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRolePermissionsBoundaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutRolePermissionsBoundaryRequest(_a0 *iam.PutRolePermissionsBoundaryInput) (*request.Request, *iam.PutRolePermissionsBoundaryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.PutRolePermissionsBoundaryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.PutRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(1).(func(*iam.PutRolePermissionsBoundaryInput) *iam.PutRolePermissionsBoundaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.PutRolePermissionsBoundaryOutput)
		}
	}

	return r0, r1
}

// PutRolePermissionsBoundaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) PutRolePermissionsBoundaryWithContext(_a0 context.Context, _a1 *iam.PutRolePermissionsBoundaryInput, _a2 ...request.Option) (*iam.PutRolePermissionsBoundaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.PutRolePermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.PutRolePermissionsBoundaryInput, ...request.Option) *iam.PutRolePermissionsBoundaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutRolePermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.PutRolePermissionsBoundaryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutRolePolicy(_a0 *iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.PutRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.PutRolePolicyInput) *iam.PutRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.PutRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutRolePolicyRequest(_a0 *iam.PutRolePolicyInput) (*request.Request, *iam.PutRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.PutRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.PutRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.PutRolePolicyInput) *iam.PutRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.PutRolePolicyOutput)
		}
	}

	return r0, r1
}

// PutRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) PutRolePolicyWithContext(_a0 context.Context, _a1 *iam.PutRolePolicyInput, _a2 ...request.Option) (*iam.PutRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.PutRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.PutRolePolicyInput, ...request.Option) *iam.PutRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.PutRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutUserPermissionsBoundary provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutUserPermissionsBoundary(_a0 *iam.PutUserPermissionsBoundaryInput) (*iam.PutUserPermissionsBoundaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.PutUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(*iam.PutUserPermissionsBoundaryInput) *iam.PutUserPermissionsBoundaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutUserPermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.PutUserPermissionsBoundaryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutUserPermissionsBoundaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutUserPermissionsBoundaryRequest(_a0 *iam.PutUserPermissionsBoundaryInput) (*request.Request, *iam.PutUserPermissionsBoundaryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.PutUserPermissionsBoundaryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.PutUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(1).(func(*iam.PutUserPermissionsBoundaryInput) *iam.PutUserPermissionsBoundaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.PutUserPermissionsBoundaryOutput)
		}
	}

	return r0, r1
}

// PutUserPermissionsBoundaryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) PutUserPermissionsBoundaryWithContext(_a0 context.Context, _a1 *iam.PutUserPermissionsBoundaryInput, _a2 ...request.Option) (*iam.PutUserPermissionsBoundaryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.PutUserPermissionsBoundaryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.PutUserPermissionsBoundaryInput, ...request.Option) *iam.PutUserPermissionsBoundaryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutUserPermissionsBoundaryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.PutUserPermissionsBoundaryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutUserPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutUserPolicy(_a0 *iam.PutUserPolicyInput) (*iam.PutUserPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.PutUserPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.PutUserPolicyInput) *iam.PutUserPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.PutUserPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutUserPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) PutUserPolicyRequest(_a0 *iam.PutUserPolicyInput) (*request.Request, *iam.PutUserPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.PutUserPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.PutUserPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.PutUserPolicyInput) *iam.PutUserPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.PutUserPolicyOutput)
		}
	}

	return r0, r1
}

// PutUserPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) PutUserPolicyWithContext(_a0 context.Context, _a1 *iam.PutUserPolicyInput, _a2 ...request.Option) (*iam.PutUserPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.PutUserPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.PutUserPolicyInput, ...request.Option) *iam.PutUserPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.PutUserPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.PutUserPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveClientIDFromOpenIDConnectProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveClientIDFromOpenIDConnectProvider(_a0 *iam.RemoveClientIDFromOpenIDConnectProviderInput) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.RemoveClientIDFromOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.RemoveClientIDFromOpenIDConnectProviderInput) *iam.RemoveClientIDFromOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveClientIDFromOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.RemoveClientIDFromOpenIDConnectProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveClientIDFromOpenIDConnectProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveClientIDFromOpenIDConnectProviderRequest(_a0 *iam.RemoveClientIDFromOpenIDConnectProviderInput) (*request.Request, *iam.RemoveClientIDFromOpenIDConnectProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.RemoveClientIDFromOpenIDConnectProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.RemoveClientIDFromOpenIDConnectProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.RemoveClientIDFromOpenIDConnectProviderInput) *iam.RemoveClientIDFromOpenIDConnectProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.RemoveClientIDFromOpenIDConnectProviderOutput)
		}
	}

	return r0, r1
}

// RemoveClientIDFromOpenIDConnectProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) RemoveClientIDFromOpenIDConnectProviderWithContext(_a0 context.Context, _a1 *iam.RemoveClientIDFromOpenIDConnectProviderInput, _a2 ...request.Option) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.RemoveClientIDFromOpenIDConnectProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.RemoveClientIDFromOpenIDConnectProviderInput, ...request.Option) *iam.RemoveClientIDFromOpenIDConnectProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveClientIDFromOpenIDConnectProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.RemoveClientIDFromOpenIDConnectProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromInstanceProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveRoleFromInstanceProfile(_a0 *iam.RemoveRoleFromInstanceProfileInput) (*iam.RemoveRoleFromInstanceProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.RemoveRoleFromInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.RemoveRoleFromInstanceProfileInput) *iam.RemoveRoleFromInstanceProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveRoleFromInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.RemoveRoleFromInstanceProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromInstanceProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveRoleFromInstanceProfileRequest(_a0 *iam.RemoveRoleFromInstanceProfileInput) (*request.Request, *iam.RemoveRoleFromInstanceProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.RemoveRoleFromInstanceProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.RemoveRoleFromInstanceProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.RemoveRoleFromInstanceProfileInput) *iam.RemoveRoleFromInstanceProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.RemoveRoleFromInstanceProfileOutput)
		}
	}

	return r0, r1
}

// RemoveRoleFromInstanceProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) RemoveRoleFromInstanceProfileWithContext(_a0 context.Context, _a1 *iam.RemoveRoleFromInstanceProfileInput, _a2 ...request.Option) (*iam.RemoveRoleFromInstanceProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.RemoveRoleFromInstanceProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.RemoveRoleFromInstanceProfileInput, ...request.Option) *iam.RemoveRoleFromInstanceProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveRoleFromInstanceProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.RemoveRoleFromInstanceProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveUserFromGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveUserFromGroup(_a0 *iam.RemoveUserFromGroupInput) (*iam.RemoveUserFromGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.RemoveUserFromGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.RemoveUserFromGroupInput) *iam.RemoveUserFromGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveUserFromGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.RemoveUserFromGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveUserFromGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) RemoveUserFromGroupRequest(_a0 *iam.RemoveUserFromGroupInput) (*request.Request, *iam.RemoveUserFromGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.RemoveUserFromGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.RemoveUserFromGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.RemoveUserFromGroupInput) *iam.RemoveUserFromGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.RemoveUserFromGroupOutput)
		}
	}

	return r0, r1
}

// RemoveUserFromGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) RemoveUserFromGroupWithContext(_a0 context.Context, _a1 *iam.RemoveUserFromGroupInput, _a2 ...request.Option) (*iam.RemoveUserFromGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.RemoveUserFromGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.RemoveUserFromGroupInput, ...request.Option) *iam.RemoveUserFromGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.RemoveUserFromGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.RemoveUserFromGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetServiceSpecificCredential provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ResetServiceSpecificCredential(_a0 *iam.ResetServiceSpecificCredentialInput) (*iam.ResetServiceSpecificCredentialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ResetServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(*iam.ResetServiceSpecificCredentialInput) *iam.ResetServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ResetServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ResetServiceSpecificCredentialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetServiceSpecificCredentialRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ResetServiceSpecificCredentialRequest(_a0 *iam.ResetServiceSpecificCredentialInput) (*request.Request, *iam.ResetServiceSpecificCredentialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ResetServiceSpecificCredentialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ResetServiceSpecificCredentialOutput
	if rf, ok := ret.Get(1).(func(*iam.ResetServiceSpecificCredentialInput) *iam.ResetServiceSpecificCredentialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ResetServiceSpecificCredentialOutput)
		}
	}

	return r0, r1
}

// ResetServiceSpecificCredentialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ResetServiceSpecificCredentialWithContext(_a0 context.Context, _a1 *iam.ResetServiceSpecificCredentialInput, _a2 ...request.Option) (*iam.ResetServiceSpecificCredentialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ResetServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ResetServiceSpecificCredentialInput, ...request.Option) *iam.ResetServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ResetServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ResetServiceSpecificCredentialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResyncMFADevice provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ResyncMFADevice(_a0 *iam.ResyncMFADeviceInput) (*iam.ResyncMFADeviceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.ResyncMFADeviceOutput
	if rf, ok := ret.Get(0).(func(*iam.ResyncMFADeviceInput) *iam.ResyncMFADeviceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ResyncMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.ResyncMFADeviceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResyncMFADeviceRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) ResyncMFADeviceRequest(_a0 *iam.ResyncMFADeviceInput) (*request.Request, *iam.ResyncMFADeviceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.ResyncMFADeviceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.ResyncMFADeviceOutput
	if rf, ok := ret.Get(1).(func(*iam.ResyncMFADeviceInput) *iam.ResyncMFADeviceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.ResyncMFADeviceOutput)
		}
	}

	return r0, r1
}

// ResyncMFADeviceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) ResyncMFADeviceWithContext(_a0 context.Context, _a1 *iam.ResyncMFADeviceInput, _a2 ...request.Option) (*iam.ResyncMFADeviceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.ResyncMFADeviceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.ResyncMFADeviceInput, ...request.Option) *iam.ResyncMFADeviceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.ResyncMFADeviceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.ResyncMFADeviceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetDefaultPolicyVersion provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SetDefaultPolicyVersion(_a0 *iam.SetDefaultPolicyVersionInput) (*iam.SetDefaultPolicyVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.SetDefaultPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(*iam.SetDefaultPolicyVersionInput) *iam.SetDefaultPolicyVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SetDefaultPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.SetDefaultPolicyVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetDefaultPolicyVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SetDefaultPolicyVersionRequest(_a0 *iam.SetDefaultPolicyVersionInput) (*request.Request, *iam.SetDefaultPolicyVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.SetDefaultPolicyVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.SetDefaultPolicyVersionOutput
	if rf, ok := ret.Get(1).(func(*iam.SetDefaultPolicyVersionInput) *iam.SetDefaultPolicyVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.SetDefaultPolicyVersionOutput)
		}
	}

	return r0, r1
}

// SetDefaultPolicyVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) SetDefaultPolicyVersionWithContext(_a0 context.Context, _a1 *iam.SetDefaultPolicyVersionInput, _a2 ...request.Option) (*iam.SetDefaultPolicyVersionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.SetDefaultPolicyVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SetDefaultPolicyVersionInput, ...request.Option) *iam.SetDefaultPolicyVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SetDefaultPolicyVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.SetDefaultPolicyVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetSecurityTokenServicePreferences provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SetSecurityTokenServicePreferences(_a0 *iam.SetSecurityTokenServicePreferencesInput) (*iam.SetSecurityTokenServicePreferencesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.SetSecurityTokenServicePreferencesOutput
	if rf, ok := ret.Get(0).(func(*iam.SetSecurityTokenServicePreferencesInput) *iam.SetSecurityTokenServicePreferencesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SetSecurityTokenServicePreferencesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.SetSecurityTokenServicePreferencesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SetSecurityTokenServicePreferencesRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SetSecurityTokenServicePreferencesRequest(_a0 *iam.SetSecurityTokenServicePreferencesInput) (*request.Request, *iam.SetSecurityTokenServicePreferencesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.SetSecurityTokenServicePreferencesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.SetSecurityTokenServicePreferencesOutput
	if rf, ok := ret.Get(1).(func(*iam.SetSecurityTokenServicePreferencesInput) *iam.SetSecurityTokenServicePreferencesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.SetSecurityTokenServicePreferencesOutput)
		}
	}

	return r0, r1
}

// SetSecurityTokenServicePreferencesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) SetSecurityTokenServicePreferencesWithContext(_a0 context.Context, _a1 *iam.SetSecurityTokenServicePreferencesInput, _a2 ...request.Option) (*iam.SetSecurityTokenServicePreferencesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.SetSecurityTokenServicePreferencesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SetSecurityTokenServicePreferencesInput, ...request.Option) *iam.SetSecurityTokenServicePreferencesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SetSecurityTokenServicePreferencesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.SetSecurityTokenServicePreferencesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SimulateCustomPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SimulateCustomPolicy(_a0 *iam.SimulateCustomPolicyInput) (*iam.SimulatePolicyResponse, error) {
	ret := _m.Called(_a0)

	var r0 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(0).(func(*iam.SimulateCustomPolicyInput) *iam.SimulatePolicyResponse); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SimulatePolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.SimulateCustomPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SimulateCustomPolicyPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) SimulateCustomPolicyPages(_a0 *iam.SimulateCustomPolicyInput, _a1 func(*iam.SimulatePolicyResponse, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.SimulateCustomPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SimulateCustomPolicyPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) SimulateCustomPolicyPagesWithContext(_a0 context.Context, _a1 *iam.SimulateCustomPolicyInput, _a2 func(*iam.SimulatePolicyResponse, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SimulateCustomPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SimulateCustomPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SimulateCustomPolicyRequest(_a0 *iam.SimulateCustomPolicyInput) (*request.Request, *iam.SimulatePolicyResponse) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.SimulateCustomPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(1).(func(*iam.SimulateCustomPolicyInput) *iam.SimulatePolicyResponse); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.SimulatePolicyResponse)
		}
	}

	return r0, r1
}

// SimulateCustomPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) SimulateCustomPolicyWithContext(_a0 context.Context, _a1 *iam.SimulateCustomPolicyInput, _a2 ...request.Option) (*iam.SimulatePolicyResponse, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SimulateCustomPolicyInput, ...request.Option) *iam.SimulatePolicyResponse); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SimulatePolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.SimulateCustomPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SimulatePrincipalPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SimulatePrincipalPolicy(_a0 *iam.SimulatePrincipalPolicyInput) (*iam.SimulatePolicyResponse, error) {
	ret := _m.Called(_a0)

	var r0 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(0).(func(*iam.SimulatePrincipalPolicyInput) *iam.SimulatePolicyResponse); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SimulatePolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.SimulatePrincipalPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SimulatePrincipalPolicyPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeIAM) SimulatePrincipalPolicyPages(_a0 *iam.SimulatePrincipalPolicyInput, _a1 func(*iam.SimulatePolicyResponse, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.SimulatePrincipalPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SimulatePrincipalPolicyPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeIAM) SimulatePrincipalPolicyPagesWithContext(_a0 context.Context, _a1 *iam.SimulatePrincipalPolicyInput, _a2 func(*iam.SimulatePolicyResponse, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SimulatePrincipalPolicyInput, func(*iam.SimulatePolicyResponse, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SimulatePrincipalPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) SimulatePrincipalPolicyRequest(_a0 *iam.SimulatePrincipalPolicyInput) (*request.Request, *iam.SimulatePolicyResponse) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.SimulatePrincipalPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(1).(func(*iam.SimulatePrincipalPolicyInput) *iam.SimulatePolicyResponse); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.SimulatePolicyResponse)
		}
	}

	return r0, r1
}

// SimulatePrincipalPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) SimulatePrincipalPolicyWithContext(_a0 context.Context, _a1 *iam.SimulatePrincipalPolicyInput, _a2 ...request.Option) (*iam.SimulatePolicyResponse, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.SimulatePolicyResponse
	if rf, ok := ret.Get(0).(func(context.Context, *iam.SimulatePrincipalPolicyInput, ...request.Option) *iam.SimulatePolicyResponse); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.SimulatePolicyResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.SimulatePrincipalPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) TagRole(_a0 *iam.TagRoleInput) (*iam.TagRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.TagRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.TagRoleInput) *iam.TagRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.TagRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.TagRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) TagRoleRequest(_a0 *iam.TagRoleInput) (*request.Request, *iam.TagRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.TagRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.TagRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.TagRoleInput) *iam.TagRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.TagRoleOutput)
		}
	}

	return r0, r1
}

// TagRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) TagRoleWithContext(_a0 context.Context, _a1 *iam.TagRoleInput, _a2 ...request.Option) (*iam.TagRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.TagRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.TagRoleInput, ...request.Option) *iam.TagRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.TagRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.TagRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) TagUser(_a0 *iam.TagUserInput) (*iam.TagUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.TagUserOutput
	if rf, ok := ret.Get(0).(func(*iam.TagUserInput) *iam.TagUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.TagUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.TagUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) TagUserRequest(_a0 *iam.TagUserInput) (*request.Request, *iam.TagUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.TagUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.TagUserOutput
	if rf, ok := ret.Get(1).(func(*iam.TagUserInput) *iam.TagUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.TagUserOutput)
		}
	}

	return r0, r1
}

// TagUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) TagUserWithContext(_a0 context.Context, _a1 *iam.TagUserInput, _a2 ...request.Option) (*iam.TagUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.TagUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.TagUserInput, ...request.Option) *iam.TagUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.TagUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.TagUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UntagRole(_a0 *iam.UntagRoleInput) (*iam.UntagRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UntagRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.UntagRoleInput) *iam.UntagRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UntagRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UntagRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UntagRoleRequest(_a0 *iam.UntagRoleInput) (*request.Request, *iam.UntagRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UntagRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UntagRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.UntagRoleInput) *iam.UntagRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UntagRoleOutput)
		}
	}

	return r0, r1
}

// UntagRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UntagRoleWithContext(_a0 context.Context, _a1 *iam.UntagRoleInput, _a2 ...request.Option) (*iam.UntagRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UntagRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UntagRoleInput, ...request.Option) *iam.UntagRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UntagRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UntagRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UntagUser(_a0 *iam.UntagUserInput) (*iam.UntagUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UntagUserOutput
	if rf, ok := ret.Get(0).(func(*iam.UntagUserInput) *iam.UntagUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UntagUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UntagUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UntagUserRequest(_a0 *iam.UntagUserInput) (*request.Request, *iam.UntagUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UntagUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UntagUserOutput
	if rf, ok := ret.Get(1).(func(*iam.UntagUserInput) *iam.UntagUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UntagUserOutput)
		}
	}

	return r0, r1
}

// UntagUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UntagUserWithContext(_a0 context.Context, _a1 *iam.UntagUserInput, _a2 ...request.Option) (*iam.UntagUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UntagUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UntagUserInput, ...request.Option) *iam.UntagUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UntagUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UntagUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAccessKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAccessKey(_a0 *iam.UpdateAccessKeyInput) (*iam.UpdateAccessKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateAccessKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateAccessKeyInput) *iam.UpdateAccessKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateAccessKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAccessKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAccessKeyRequest(_a0 *iam.UpdateAccessKeyInput) (*request.Request, *iam.UpdateAccessKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateAccessKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateAccessKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateAccessKeyInput) *iam.UpdateAccessKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateAccessKeyOutput)
		}
	}

	return r0, r1
}

// UpdateAccessKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateAccessKeyWithContext(_a0 context.Context, _a1 *iam.UpdateAccessKeyInput, _a2 ...request.Option) (*iam.UpdateAccessKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateAccessKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateAccessKeyInput, ...request.Option) *iam.UpdateAccessKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAccessKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateAccessKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAccountPasswordPolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAccountPasswordPolicy(_a0 *iam.UpdateAccountPasswordPolicyInput) (*iam.UpdateAccountPasswordPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateAccountPasswordPolicyInput) *iam.UpdateAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateAccountPasswordPolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAccountPasswordPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAccountPasswordPolicyRequest(_a0 *iam.UpdateAccountPasswordPolicyInput) (*request.Request, *iam.UpdateAccountPasswordPolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateAccountPasswordPolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateAccountPasswordPolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateAccountPasswordPolicyInput) *iam.UpdateAccountPasswordPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateAccountPasswordPolicyOutput)
		}
	}

	return r0, r1
}

// UpdateAccountPasswordPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateAccountPasswordPolicyWithContext(_a0 context.Context, _a1 *iam.UpdateAccountPasswordPolicyInput, _a2 ...request.Option) (*iam.UpdateAccountPasswordPolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateAccountPasswordPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateAccountPasswordPolicyInput, ...request.Option) *iam.UpdateAccountPasswordPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAccountPasswordPolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateAccountPasswordPolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAssumeRolePolicy provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAssumeRolePolicy(_a0 *iam.UpdateAssumeRolePolicyInput) (*iam.UpdateAssumeRolePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateAssumeRolePolicyOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateAssumeRolePolicyInput) *iam.UpdateAssumeRolePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAssumeRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateAssumeRolePolicyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAssumeRolePolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateAssumeRolePolicyRequest(_a0 *iam.UpdateAssumeRolePolicyInput) (*request.Request, *iam.UpdateAssumeRolePolicyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateAssumeRolePolicyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateAssumeRolePolicyOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateAssumeRolePolicyInput) *iam.UpdateAssumeRolePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateAssumeRolePolicyOutput)
		}
	}

	return r0, r1
}

// UpdateAssumeRolePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateAssumeRolePolicyWithContext(_a0 context.Context, _a1 *iam.UpdateAssumeRolePolicyInput, _a2 ...request.Option) (*iam.UpdateAssumeRolePolicyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateAssumeRolePolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateAssumeRolePolicyInput, ...request.Option) *iam.UpdateAssumeRolePolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateAssumeRolePolicyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateAssumeRolePolicyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGroup provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateGroup(_a0 *iam.UpdateGroupInput) (*iam.UpdateGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateGroupOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateGroupInput) *iam.UpdateGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateGroupRequest(_a0 *iam.UpdateGroupInput) (*request.Request, *iam.UpdateGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateGroupOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateGroupInput) *iam.UpdateGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateGroupOutput)
		}
	}

	return r0, r1
}

// UpdateGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateGroupWithContext(_a0 context.Context, _a1 *iam.UpdateGroupInput, _a2 ...request.Option) (*iam.UpdateGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateGroupInput, ...request.Option) *iam.UpdateGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateLoginProfile provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateLoginProfile(_a0 *iam.UpdateLoginProfileInput) (*iam.UpdateLoginProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateLoginProfileOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateLoginProfileInput) *iam.UpdateLoginProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateLoginProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateLoginProfileRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateLoginProfileRequest(_a0 *iam.UpdateLoginProfileInput) (*request.Request, *iam.UpdateLoginProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateLoginProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateLoginProfileOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateLoginProfileInput) *iam.UpdateLoginProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateLoginProfileOutput)
		}
	}

	return r0, r1
}

// UpdateLoginProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateLoginProfileWithContext(_a0 context.Context, _a1 *iam.UpdateLoginProfileInput, _a2 ...request.Option) (*iam.UpdateLoginProfileOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateLoginProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateLoginProfileInput, ...request.Option) *iam.UpdateLoginProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateLoginProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateLoginProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateOpenIDConnectProviderThumbprint provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateOpenIDConnectProviderThumbprint(_a0 *iam.UpdateOpenIDConnectProviderThumbprintInput) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateOpenIDConnectProviderThumbprintOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateOpenIDConnectProviderThumbprintInput) *iam.UpdateOpenIDConnectProviderThumbprintOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateOpenIDConnectProviderThumbprintOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateOpenIDConnectProviderThumbprintInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateOpenIDConnectProviderThumbprintRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateOpenIDConnectProviderThumbprintRequest(_a0 *iam.UpdateOpenIDConnectProviderThumbprintInput) (*request.Request, *iam.UpdateOpenIDConnectProviderThumbprintOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateOpenIDConnectProviderThumbprintInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateOpenIDConnectProviderThumbprintOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateOpenIDConnectProviderThumbprintInput) *iam.UpdateOpenIDConnectProviderThumbprintOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateOpenIDConnectProviderThumbprintOutput)
		}
	}

	return r0, r1
}

// UpdateOpenIDConnectProviderThumbprintWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateOpenIDConnectProviderThumbprintWithContext(_a0 context.Context, _a1 *iam.UpdateOpenIDConnectProviderThumbprintInput, _a2 ...request.Option) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateOpenIDConnectProviderThumbprintOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateOpenIDConnectProviderThumbprintInput, ...request.Option) *iam.UpdateOpenIDConnectProviderThumbprintOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateOpenIDConnectProviderThumbprintOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateOpenIDConnectProviderThumbprintInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRole provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateRole(_a0 *iam.UpdateRoleInput) (*iam.UpdateRoleOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateRoleOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateRoleInput) *iam.UpdateRoleOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateRoleInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRoleDescription provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateRoleDescription(_a0 *iam.UpdateRoleDescriptionInput) (*iam.UpdateRoleDescriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateRoleDescriptionOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateRoleDescriptionInput) *iam.UpdateRoleDescriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateRoleDescriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateRoleDescriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRoleDescriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateRoleDescriptionRequest(_a0 *iam.UpdateRoleDescriptionInput) (*request.Request, *iam.UpdateRoleDescriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateRoleDescriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateRoleDescriptionOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateRoleDescriptionInput) *iam.UpdateRoleDescriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateRoleDescriptionOutput)
		}
	}

	return r0, r1
}

// UpdateRoleDescriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateRoleDescriptionWithContext(_a0 context.Context, _a1 *iam.UpdateRoleDescriptionInput, _a2 ...request.Option) (*iam.UpdateRoleDescriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateRoleDescriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateRoleDescriptionInput, ...request.Option) *iam.UpdateRoleDescriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateRoleDescriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateRoleDescriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRoleRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateRoleRequest(_a0 *iam.UpdateRoleInput) (*request.Request, *iam.UpdateRoleOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateRoleInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateRoleOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateRoleInput) *iam.UpdateRoleOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateRoleOutput)
		}
	}

	return r0, r1
}

// UpdateRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateRoleWithContext(_a0 context.Context, _a1 *iam.UpdateRoleInput, _a2 ...request.Option) (*iam.UpdateRoleOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateRoleOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateRoleInput, ...request.Option) *iam.UpdateRoleOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateRoleOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateRoleInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSAMLProvider provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSAMLProvider(_a0 *iam.UpdateSAMLProviderInput) (*iam.UpdateSAMLProviderOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateSAMLProviderInput) *iam.UpdateSAMLProviderOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateSAMLProviderInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSAMLProviderRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSAMLProviderRequest(_a0 *iam.UpdateSAMLProviderInput) (*request.Request, *iam.UpdateSAMLProviderOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateSAMLProviderInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateSAMLProviderOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateSAMLProviderInput) *iam.UpdateSAMLProviderOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateSAMLProviderOutput)
		}
	}

	return r0, r1
}

// UpdateSAMLProviderWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateSAMLProviderWithContext(_a0 context.Context, _a1 *iam.UpdateSAMLProviderInput, _a2 ...request.Option) (*iam.UpdateSAMLProviderOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateSAMLProviderOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateSAMLProviderInput, ...request.Option) *iam.UpdateSAMLProviderOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSAMLProviderOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateSAMLProviderInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSSHPublicKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSSHPublicKey(_a0 *iam.UpdateSSHPublicKeyInput) (*iam.UpdateSSHPublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateSSHPublicKeyInput) *iam.UpdateSSHPublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateSSHPublicKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSSHPublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSSHPublicKeyRequest(_a0 *iam.UpdateSSHPublicKeyInput) (*request.Request, *iam.UpdateSSHPublicKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateSSHPublicKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateSSHPublicKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateSSHPublicKeyInput) *iam.UpdateSSHPublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateSSHPublicKeyOutput)
		}
	}

	return r0, r1
}

// UpdateSSHPublicKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateSSHPublicKeyWithContext(_a0 context.Context, _a1 *iam.UpdateSSHPublicKeyInput, _a2 ...request.Option) (*iam.UpdateSSHPublicKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateSSHPublicKeyInput, ...request.Option) *iam.UpdateSSHPublicKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateSSHPublicKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateServerCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateServerCertificate(_a0 *iam.UpdateServerCertificateInput) (*iam.UpdateServerCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateServerCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateServerCertificateInput) *iam.UpdateServerCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateServerCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateServerCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateServerCertificateRequest(_a0 *iam.UpdateServerCertificateInput) (*request.Request, *iam.UpdateServerCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateServerCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateServerCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateServerCertificateInput) *iam.UpdateServerCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateServerCertificateOutput)
		}
	}

	return r0, r1
}

// UpdateServerCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateServerCertificateWithContext(_a0 context.Context, _a1 *iam.UpdateServerCertificateInput, _a2 ...request.Option) (*iam.UpdateServerCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateServerCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateServerCertificateInput, ...request.Option) *iam.UpdateServerCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateServerCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateServiceSpecificCredential provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateServiceSpecificCredential(_a0 *iam.UpdateServiceSpecificCredentialInput) (*iam.UpdateServiceSpecificCredentialOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateServiceSpecificCredentialInput) *iam.UpdateServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateServiceSpecificCredentialInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateServiceSpecificCredentialRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateServiceSpecificCredentialRequest(_a0 *iam.UpdateServiceSpecificCredentialInput) (*request.Request, *iam.UpdateServiceSpecificCredentialOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateServiceSpecificCredentialInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateServiceSpecificCredentialInput) *iam.UpdateServiceSpecificCredentialOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateServiceSpecificCredentialOutput)
		}
	}

	return r0, r1
}

// UpdateServiceSpecificCredentialWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateServiceSpecificCredentialWithContext(_a0 context.Context, _a1 *iam.UpdateServiceSpecificCredentialInput, _a2 ...request.Option) (*iam.UpdateServiceSpecificCredentialOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateServiceSpecificCredentialOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateServiceSpecificCredentialInput, ...request.Option) *iam.UpdateServiceSpecificCredentialOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateServiceSpecificCredentialOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateServiceSpecificCredentialInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSigningCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSigningCertificate(_a0 *iam.UpdateSigningCertificateInput) (*iam.UpdateSigningCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateSigningCertificateInput) *iam.UpdateSigningCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateSigningCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateSigningCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateSigningCertificateRequest(_a0 *iam.UpdateSigningCertificateInput) (*request.Request, *iam.UpdateSigningCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateSigningCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateSigningCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateSigningCertificateInput) *iam.UpdateSigningCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateSigningCertificateOutput)
		}
	}

	return r0, r1
}

// UpdateSigningCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateSigningCertificateWithContext(_a0 context.Context, _a1 *iam.UpdateSigningCertificateInput, _a2 ...request.Option) (*iam.UpdateSigningCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateSigningCertificateInput, ...request.Option) *iam.UpdateSigningCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateSigningCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateUser provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateUser(_a0 *iam.UpdateUserInput) (*iam.UpdateUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UpdateUserOutput
	if rf, ok := ret.Get(0).(func(*iam.UpdateUserInput) *iam.UpdateUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UpdateUserInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UpdateUserRequest(_a0 *iam.UpdateUserInput) (*request.Request, *iam.UpdateUserOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UpdateUserInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UpdateUserOutput
	if rf, ok := ret.Get(1).(func(*iam.UpdateUserInput) *iam.UpdateUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UpdateUserOutput)
		}
	}

	return r0, r1
}

// UpdateUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UpdateUserWithContext(_a0 context.Context, _a1 *iam.UpdateUserInput, _a2 ...request.Option) (*iam.UpdateUserOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UpdateUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UpdateUserInput, ...request.Option) *iam.UpdateUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UpdateUserOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UpdateUserInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadSSHPublicKey provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadSSHPublicKey(_a0 *iam.UploadSSHPublicKeyInput) (*iam.UploadSSHPublicKeyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UploadSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(*iam.UploadSSHPublicKeyInput) *iam.UploadSSHPublicKeyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UploadSSHPublicKeyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadSSHPublicKeyRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadSSHPublicKeyRequest(_a0 *iam.UploadSSHPublicKeyInput) (*request.Request, *iam.UploadSSHPublicKeyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UploadSSHPublicKeyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UploadSSHPublicKeyOutput
	if rf, ok := ret.Get(1).(func(*iam.UploadSSHPublicKeyInput) *iam.UploadSSHPublicKeyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UploadSSHPublicKeyOutput)
		}
	}

	return r0, r1
}

// UploadSSHPublicKeyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UploadSSHPublicKeyWithContext(_a0 context.Context, _a1 *iam.UploadSSHPublicKeyInput, _a2 ...request.Option) (*iam.UploadSSHPublicKeyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UploadSSHPublicKeyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UploadSSHPublicKeyInput, ...request.Option) *iam.UploadSSHPublicKeyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadSSHPublicKeyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UploadSSHPublicKeyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadServerCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadServerCertificate(_a0 *iam.UploadServerCertificateInput) (*iam.UploadServerCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UploadServerCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.UploadServerCertificateInput) *iam.UploadServerCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UploadServerCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadServerCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadServerCertificateRequest(_a0 *iam.UploadServerCertificateInput) (*request.Request, *iam.UploadServerCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UploadServerCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UploadServerCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.UploadServerCertificateInput) *iam.UploadServerCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UploadServerCertificateOutput)
		}
	}

	return r0, r1
}

// UploadServerCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UploadServerCertificateWithContext(_a0 context.Context, _a1 *iam.UploadServerCertificateInput, _a2 ...request.Option) (*iam.UploadServerCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UploadServerCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UploadServerCertificateInput, ...request.Option) *iam.UploadServerCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadServerCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UploadServerCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadSigningCertificate provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadSigningCertificate(_a0 *iam.UploadSigningCertificateInput) (*iam.UploadSigningCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *iam.UploadSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(*iam.UploadSigningCertificateInput) *iam.UploadSigningCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*iam.UploadSigningCertificateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UploadSigningCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeIAM) UploadSigningCertificateRequest(_a0 *iam.UploadSigningCertificateInput) (*request.Request, *iam.UploadSigningCertificateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*iam.UploadSigningCertificateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *iam.UploadSigningCertificateOutput
	if rf, ok := ret.Get(1).(func(*iam.UploadSigningCertificateInput) *iam.UploadSigningCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*iam.UploadSigningCertificateOutput)
		}
	}

	return r0, r1
}

// UploadSigningCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) UploadSigningCertificateWithContext(_a0 context.Context, _a1 *iam.UploadSigningCertificateInput, _a2 ...request.Option) (*iam.UploadSigningCertificateOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *iam.UploadSigningCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *iam.UploadSigningCertificateInput, ...request.Option) *iam.UploadSigningCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*iam.UploadSigningCertificateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *iam.UploadSigningCertificateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilInstanceProfileExists provides a mock function with given fields: _a0
func (_m *MockFakeIAM) WaitUntilInstanceProfileExists(_a0 *iam.GetInstanceProfileInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetInstanceProfileInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceProfileExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) WaitUntilInstanceProfileExistsWithContext(_a0 context.Context, _a1 *iam.GetInstanceProfileInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetInstanceProfileInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilPolicyExists provides a mock function with given fields: _a0
func (_m *MockFakeIAM) WaitUntilPolicyExists(_a0 *iam.GetPolicyInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetPolicyInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilPolicyExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) WaitUntilPolicyExistsWithContext(_a0 context.Context, _a1 *iam.GetPolicyInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetPolicyInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilRoleExists provides a mock function with given fields: _a0
func (_m *MockFakeIAM) WaitUntilRoleExists(_a0 *iam.GetRoleInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetRoleInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilRoleExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) WaitUntilRoleExistsWithContext(_a0 context.Context, _a1 *iam.GetRoleInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetRoleInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilUserExists provides a mock function with given fields: _a0
func (_m *MockFakeIAM) WaitUntilUserExists(_a0 *iam.GetUserInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*iam.GetUserInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilUserExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeIAM) WaitUntilUserExistsWithContext(_a0 context.Context, _a1 *iam.GetUserInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *iam.GetUserInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}