test/aws/mock_FakeELB.go

// Code generated by mockery v2.10.0. DO NOT EDIT.

package aws

import (
	context "context"

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

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

// MockFakeELB is an autogenerated mock type for the FakeELB type
type MockFakeELB struct {
	mock.Mock
}

// AddTags provides a mock function with given fields: _a0
func (_m *MockFakeELB) AddTags(_a0 *elb.AddTagsInput) (*elb.AddTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.AddTagsOutput
	if rf, ok := ret.Get(0).(func(*elb.AddTagsInput) *elb.AddTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.AddTagsOutput)
		}
	}

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

	return r0, r1
}

// AddTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) AddTagsRequest(_a0 *elb.AddTagsInput) (*request.Request, *elb.AddTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.AddTagsOutput
	if rf, ok := ret.Get(1).(func(*elb.AddTagsInput) *elb.AddTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.AddTagsOutput)
		}
	}

	return r0, r1
}

// AddTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) AddTagsWithContext(_a0 context.Context, _a1 *elb.AddTagsInput, _a2 ...request.Option) (*elb.AddTagsOutput, 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 *elb.AddTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.AddTagsInput, ...request.Option) *elb.AddTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.AddTagsOutput)
		}
	}

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

	return r0, r1
}

// ApplySecurityGroupsToLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) ApplySecurityGroupsToLoadBalancer(_a0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*elb.ApplySecurityGroupsToLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.ApplySecurityGroupsToLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.ApplySecurityGroupsToLoadBalancerInput) *elb.ApplySecurityGroupsToLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ApplySecurityGroupsToLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// ApplySecurityGroupsToLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) ApplySecurityGroupsToLoadBalancerRequest(_a0 *elb.ApplySecurityGroupsToLoadBalancerInput) (*request.Request, *elb.ApplySecurityGroupsToLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.ApplySecurityGroupsToLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.ApplySecurityGroupsToLoadBalancerInput) *elb.ApplySecurityGroupsToLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.ApplySecurityGroupsToLoadBalancerOutput)
		}
	}

	return r0, r1
}

// ApplySecurityGroupsToLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) ApplySecurityGroupsToLoadBalancerWithContext(_a0 context.Context, _a1 *elb.ApplySecurityGroupsToLoadBalancerInput, _a2 ...request.Option) (*elb.ApplySecurityGroupsToLoadBalancerOutput, 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 *elb.ApplySecurityGroupsToLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.ApplySecurityGroupsToLoadBalancerInput, ...request.Option) *elb.ApplySecurityGroupsToLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ApplySecurityGroupsToLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// AttachLoadBalancerToSubnets provides a mock function with given fields: _a0
func (_m *MockFakeELB) AttachLoadBalancerToSubnets(_a0 *elb.AttachLoadBalancerToSubnetsInput) (*elb.AttachLoadBalancerToSubnetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.AttachLoadBalancerToSubnetsOutput
	if rf, ok := ret.Get(0).(func(*elb.AttachLoadBalancerToSubnetsInput) *elb.AttachLoadBalancerToSubnetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.AttachLoadBalancerToSubnetsOutput)
		}
	}

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

	return r0, r1
}

// AttachLoadBalancerToSubnetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) AttachLoadBalancerToSubnetsRequest(_a0 *elb.AttachLoadBalancerToSubnetsInput) (*request.Request, *elb.AttachLoadBalancerToSubnetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.AttachLoadBalancerToSubnetsOutput
	if rf, ok := ret.Get(1).(func(*elb.AttachLoadBalancerToSubnetsInput) *elb.AttachLoadBalancerToSubnetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.AttachLoadBalancerToSubnetsOutput)
		}
	}

	return r0, r1
}

// AttachLoadBalancerToSubnetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) AttachLoadBalancerToSubnetsWithContext(_a0 context.Context, _a1 *elb.AttachLoadBalancerToSubnetsInput, _a2 ...request.Option) (*elb.AttachLoadBalancerToSubnetsOutput, 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 *elb.AttachLoadBalancerToSubnetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.AttachLoadBalancerToSubnetsInput, ...request.Option) *elb.AttachLoadBalancerToSubnetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.AttachLoadBalancerToSubnetsOutput)
		}
	}

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

	return r0, r1
}

// ConfigureHealthCheck provides a mock function with given fields: _a0
func (_m *MockFakeELB) ConfigureHealthCheck(_a0 *elb.ConfigureHealthCheckInput) (*elb.ConfigureHealthCheckOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.ConfigureHealthCheckOutput
	if rf, ok := ret.Get(0).(func(*elb.ConfigureHealthCheckInput) *elb.ConfigureHealthCheckOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ConfigureHealthCheckOutput)
		}
	}

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

	return r0, r1
}

// ConfigureHealthCheckRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) ConfigureHealthCheckRequest(_a0 *elb.ConfigureHealthCheckInput) (*request.Request, *elb.ConfigureHealthCheckOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.ConfigureHealthCheckOutput
	if rf, ok := ret.Get(1).(func(*elb.ConfigureHealthCheckInput) *elb.ConfigureHealthCheckOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.ConfigureHealthCheckOutput)
		}
	}

	return r0, r1
}

// ConfigureHealthCheckWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) ConfigureHealthCheckWithContext(_a0 context.Context, _a1 *elb.ConfigureHealthCheckInput, _a2 ...request.Option) (*elb.ConfigureHealthCheckOutput, 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 *elb.ConfigureHealthCheckOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.ConfigureHealthCheckInput, ...request.Option) *elb.ConfigureHealthCheckOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ConfigureHealthCheckOutput)
		}
	}

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

	return r0, r1
}

// CreateAppCookieStickinessPolicy provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateAppCookieStickinessPolicy(_a0 *elb.CreateAppCookieStickinessPolicyInput) (*elb.CreateAppCookieStickinessPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.CreateAppCookieStickinessPolicyOutput
	if rf, ok := ret.Get(0).(func(*elb.CreateAppCookieStickinessPolicyInput) *elb.CreateAppCookieStickinessPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateAppCookieStickinessPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateAppCookieStickinessPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateAppCookieStickinessPolicyRequest(_a0 *elb.CreateAppCookieStickinessPolicyInput) (*request.Request, *elb.CreateAppCookieStickinessPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.CreateAppCookieStickinessPolicyOutput
	if rf, ok := ret.Get(1).(func(*elb.CreateAppCookieStickinessPolicyInput) *elb.CreateAppCookieStickinessPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.CreateAppCookieStickinessPolicyOutput)
		}
	}

	return r0, r1
}

// CreateAppCookieStickinessPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) CreateAppCookieStickinessPolicyWithContext(_a0 context.Context, _a1 *elb.CreateAppCookieStickinessPolicyInput, _a2 ...request.Option) (*elb.CreateAppCookieStickinessPolicyOutput, 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 *elb.CreateAppCookieStickinessPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.CreateAppCookieStickinessPolicyInput, ...request.Option) *elb.CreateAppCookieStickinessPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateAppCookieStickinessPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateLBCookieStickinessPolicy provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLBCookieStickinessPolicy(_a0 *elb.CreateLBCookieStickinessPolicyInput) (*elb.CreateLBCookieStickinessPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.CreateLBCookieStickinessPolicyOutput
	if rf, ok := ret.Get(0).(func(*elb.CreateLBCookieStickinessPolicyInput) *elb.CreateLBCookieStickinessPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLBCookieStickinessPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateLBCookieStickinessPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLBCookieStickinessPolicyRequest(_a0 *elb.CreateLBCookieStickinessPolicyInput) (*request.Request, *elb.CreateLBCookieStickinessPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.CreateLBCookieStickinessPolicyOutput
	if rf, ok := ret.Get(1).(func(*elb.CreateLBCookieStickinessPolicyInput) *elb.CreateLBCookieStickinessPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.CreateLBCookieStickinessPolicyOutput)
		}
	}

	return r0, r1
}

// CreateLBCookieStickinessPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) CreateLBCookieStickinessPolicyWithContext(_a0 context.Context, _a1 *elb.CreateLBCookieStickinessPolicyInput, _a2 ...request.Option) (*elb.CreateLBCookieStickinessPolicyOutput, 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 *elb.CreateLBCookieStickinessPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.CreateLBCookieStickinessPolicyInput, ...request.Option) *elb.CreateLBCookieStickinessPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLBCookieStickinessPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancer(_a0 *elb.CreateLoadBalancerInput) (*elb.CreateLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.CreateLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.CreateLoadBalancerInput) *elb.CreateLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancerListeners provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancerListeners(_a0 *elb.CreateLoadBalancerListenersInput) (*elb.CreateLoadBalancerListenersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.CreateLoadBalancerListenersOutput
	if rf, ok := ret.Get(0).(func(*elb.CreateLoadBalancerListenersInput) *elb.CreateLoadBalancerListenersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerListenersOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancerListenersRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancerListenersRequest(_a0 *elb.CreateLoadBalancerListenersInput) (*request.Request, *elb.CreateLoadBalancerListenersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.CreateLoadBalancerListenersOutput
	if rf, ok := ret.Get(1).(func(*elb.CreateLoadBalancerListenersInput) *elb.CreateLoadBalancerListenersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.CreateLoadBalancerListenersOutput)
		}
	}

	return r0, r1
}

// CreateLoadBalancerListenersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) CreateLoadBalancerListenersWithContext(_a0 context.Context, _a1 *elb.CreateLoadBalancerListenersInput, _a2 ...request.Option) (*elb.CreateLoadBalancerListenersOutput, 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 *elb.CreateLoadBalancerListenersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.CreateLoadBalancerListenersInput, ...request.Option) *elb.CreateLoadBalancerListenersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerListenersOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancerPolicy provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancerPolicy(_a0 *elb.CreateLoadBalancerPolicyInput) (*elb.CreateLoadBalancerPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.CreateLoadBalancerPolicyOutput
	if rf, ok := ret.Get(0).(func(*elb.CreateLoadBalancerPolicyInput) *elb.CreateLoadBalancerPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancerPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancerPolicyRequest(_a0 *elb.CreateLoadBalancerPolicyInput) (*request.Request, *elb.CreateLoadBalancerPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.CreateLoadBalancerPolicyOutput
	if rf, ok := ret.Get(1).(func(*elb.CreateLoadBalancerPolicyInput) *elb.CreateLoadBalancerPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.CreateLoadBalancerPolicyOutput)
		}
	}

	return r0, r1
}

// CreateLoadBalancerPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) CreateLoadBalancerPolicyWithContext(_a0 context.Context, _a1 *elb.CreateLoadBalancerPolicyInput, _a2 ...request.Option) (*elb.CreateLoadBalancerPolicyOutput, 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 *elb.CreateLoadBalancerPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.CreateLoadBalancerPolicyInput, ...request.Option) *elb.CreateLoadBalancerPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerPolicyOutput)
		}
	}

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

	return r0, r1
}

// CreateLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) CreateLoadBalancerRequest(_a0 *elb.CreateLoadBalancerInput) (*request.Request, *elb.CreateLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.CreateLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.CreateLoadBalancerInput) *elb.CreateLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.CreateLoadBalancerOutput)
		}
	}

	return r0, r1
}

// CreateLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) CreateLoadBalancerWithContext(_a0 context.Context, _a1 *elb.CreateLoadBalancerInput, _a2 ...request.Option) (*elb.CreateLoadBalancerOutput, 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 *elb.CreateLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.CreateLoadBalancerInput, ...request.Option) *elb.CreateLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.CreateLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancer(_a0 *elb.DeleteLoadBalancerInput) (*elb.DeleteLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DeleteLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.DeleteLoadBalancerInput) *elb.DeleteLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancerListeners provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancerListeners(_a0 *elb.DeleteLoadBalancerListenersInput) (*elb.DeleteLoadBalancerListenersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DeleteLoadBalancerListenersOutput
	if rf, ok := ret.Get(0).(func(*elb.DeleteLoadBalancerListenersInput) *elb.DeleteLoadBalancerListenersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerListenersOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancerListenersRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancerListenersRequest(_a0 *elb.DeleteLoadBalancerListenersInput) (*request.Request, *elb.DeleteLoadBalancerListenersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DeleteLoadBalancerListenersOutput
	if rf, ok := ret.Get(1).(func(*elb.DeleteLoadBalancerListenersInput) *elb.DeleteLoadBalancerListenersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DeleteLoadBalancerListenersOutput)
		}
	}

	return r0, r1
}

// DeleteLoadBalancerListenersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DeleteLoadBalancerListenersWithContext(_a0 context.Context, _a1 *elb.DeleteLoadBalancerListenersInput, _a2 ...request.Option) (*elb.DeleteLoadBalancerListenersOutput, 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 *elb.DeleteLoadBalancerListenersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DeleteLoadBalancerListenersInput, ...request.Option) *elb.DeleteLoadBalancerListenersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerListenersOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancerPolicy provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancerPolicy(_a0 *elb.DeleteLoadBalancerPolicyInput) (*elb.DeleteLoadBalancerPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DeleteLoadBalancerPolicyOutput
	if rf, ok := ret.Get(0).(func(*elb.DeleteLoadBalancerPolicyInput) *elb.DeleteLoadBalancerPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerPolicyOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancerPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancerPolicyRequest(_a0 *elb.DeleteLoadBalancerPolicyInput) (*request.Request, *elb.DeleteLoadBalancerPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DeleteLoadBalancerPolicyOutput
	if rf, ok := ret.Get(1).(func(*elb.DeleteLoadBalancerPolicyInput) *elb.DeleteLoadBalancerPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DeleteLoadBalancerPolicyOutput)
		}
	}

	return r0, r1
}

// DeleteLoadBalancerPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DeleteLoadBalancerPolicyWithContext(_a0 context.Context, _a1 *elb.DeleteLoadBalancerPolicyInput, _a2 ...request.Option) (*elb.DeleteLoadBalancerPolicyOutput, 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 *elb.DeleteLoadBalancerPolicyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DeleteLoadBalancerPolicyInput, ...request.Option) *elb.DeleteLoadBalancerPolicyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerPolicyOutput)
		}
	}

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

	return r0, r1
}

// DeleteLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeleteLoadBalancerRequest(_a0 *elb.DeleteLoadBalancerInput) (*request.Request, *elb.DeleteLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DeleteLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.DeleteLoadBalancerInput) *elb.DeleteLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DeleteLoadBalancerOutput)
		}
	}

	return r0, r1
}

// DeleteLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DeleteLoadBalancerWithContext(_a0 context.Context, _a1 *elb.DeleteLoadBalancerInput, _a2 ...request.Option) (*elb.DeleteLoadBalancerOutput, 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 *elb.DeleteLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DeleteLoadBalancerInput, ...request.Option) *elb.DeleteLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeleteLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DeregisterInstancesFromLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeregisterInstancesFromLoadBalancer(_a0 *elb.DeregisterInstancesFromLoadBalancerInput) (*elb.DeregisterInstancesFromLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DeregisterInstancesFromLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.DeregisterInstancesFromLoadBalancerInput) *elb.DeregisterInstancesFromLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeregisterInstancesFromLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DeregisterInstancesFromLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DeregisterInstancesFromLoadBalancerRequest(_a0 *elb.DeregisterInstancesFromLoadBalancerInput) (*request.Request, *elb.DeregisterInstancesFromLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DeregisterInstancesFromLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.DeregisterInstancesFromLoadBalancerInput) *elb.DeregisterInstancesFromLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DeregisterInstancesFromLoadBalancerOutput)
		}
	}

	return r0, r1
}

// DeregisterInstancesFromLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DeregisterInstancesFromLoadBalancerWithContext(_a0 context.Context, _a1 *elb.DeregisterInstancesFromLoadBalancerInput, _a2 ...request.Option) (*elb.DeregisterInstancesFromLoadBalancerOutput, 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 *elb.DeregisterInstancesFromLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DeregisterInstancesFromLoadBalancerInput, ...request.Option) *elb.DeregisterInstancesFromLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DeregisterInstancesFromLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DescribeAccountLimits provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeAccountLimits(_a0 *elb.DescribeAccountLimitsInput) (*elb.DescribeAccountLimitsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeAccountLimitsOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeAccountLimitsInput) *elb.DescribeAccountLimitsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeAccountLimitsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAccountLimitsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeAccountLimitsRequest(_a0 *elb.DescribeAccountLimitsInput) (*request.Request, *elb.DescribeAccountLimitsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeAccountLimitsOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeAccountLimitsInput) *elb.DescribeAccountLimitsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeAccountLimitsOutput)
		}
	}

	return r0, r1
}

// DescribeAccountLimitsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeAccountLimitsWithContext(_a0 context.Context, _a1 *elb.DescribeAccountLimitsInput, _a2 ...request.Option) (*elb.DescribeAccountLimitsOutput, 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 *elb.DescribeAccountLimitsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeAccountLimitsInput, ...request.Option) *elb.DescribeAccountLimitsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeAccountLimitsOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceHealth provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeInstanceHealth(_a0 *elb.DescribeInstanceHealthInput) (*elb.DescribeInstanceHealthOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeInstanceHealthOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeInstanceHealthInput) *elb.DescribeInstanceHealthOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeInstanceHealthOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceHealthRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeInstanceHealthRequest(_a0 *elb.DescribeInstanceHealthInput) (*request.Request, *elb.DescribeInstanceHealthOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeInstanceHealthOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeInstanceHealthInput) *elb.DescribeInstanceHealthOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeInstanceHealthOutput)
		}
	}

	return r0, r1
}

// DescribeInstanceHealthWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeInstanceHealthWithContext(_a0 context.Context, _a1 *elb.DescribeInstanceHealthInput, _a2 ...request.Option) (*elb.DescribeInstanceHealthOutput, 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 *elb.DescribeInstanceHealthOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeInstanceHealthInput, ...request.Option) *elb.DescribeInstanceHealthOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeInstanceHealthOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerAttributes provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerAttributes(_a0 *elb.DescribeLoadBalancerAttributesInput) (*elb.DescribeLoadBalancerAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeLoadBalancerAttributesOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeLoadBalancerAttributesInput) *elb.DescribeLoadBalancerAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerAttributesRequest(_a0 *elb.DescribeLoadBalancerAttributesInput) (*request.Request, *elb.DescribeLoadBalancerAttributesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeLoadBalancerAttributesOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeLoadBalancerAttributesInput) *elb.DescribeLoadBalancerAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeLoadBalancerAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeLoadBalancerAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeLoadBalancerAttributesWithContext(_a0 context.Context, _a1 *elb.DescribeLoadBalancerAttributesInput, _a2 ...request.Option) (*elb.DescribeLoadBalancerAttributesOutput, 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 *elb.DescribeLoadBalancerAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeLoadBalancerAttributesInput, ...request.Option) *elb.DescribeLoadBalancerAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerAttributesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerPolicies provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerPolicies(_a0 *elb.DescribeLoadBalancerPoliciesInput) (*elb.DescribeLoadBalancerPoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeLoadBalancerPoliciesOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeLoadBalancerPoliciesInput) *elb.DescribeLoadBalancerPoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerPoliciesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerPoliciesRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerPoliciesRequest(_a0 *elb.DescribeLoadBalancerPoliciesInput) (*request.Request, *elb.DescribeLoadBalancerPoliciesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeLoadBalancerPoliciesOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeLoadBalancerPoliciesInput) *elb.DescribeLoadBalancerPoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeLoadBalancerPoliciesOutput)
		}
	}

	return r0, r1
}

// DescribeLoadBalancerPoliciesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeLoadBalancerPoliciesWithContext(_a0 context.Context, _a1 *elb.DescribeLoadBalancerPoliciesInput, _a2 ...request.Option) (*elb.DescribeLoadBalancerPoliciesOutput, 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 *elb.DescribeLoadBalancerPoliciesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeLoadBalancerPoliciesInput, ...request.Option) *elb.DescribeLoadBalancerPoliciesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerPoliciesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerPolicyTypes provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerPolicyTypes(_a0 *elb.DescribeLoadBalancerPolicyTypesInput) (*elb.DescribeLoadBalancerPolicyTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeLoadBalancerPolicyTypesOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeLoadBalancerPolicyTypesInput) *elb.DescribeLoadBalancerPolicyTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerPolicyTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerPolicyTypesRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancerPolicyTypesRequest(_a0 *elb.DescribeLoadBalancerPolicyTypesInput) (*request.Request, *elb.DescribeLoadBalancerPolicyTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeLoadBalancerPolicyTypesOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeLoadBalancerPolicyTypesInput) *elb.DescribeLoadBalancerPolicyTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeLoadBalancerPolicyTypesOutput)
		}
	}

	return r0, r1
}

// DescribeLoadBalancerPolicyTypesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeLoadBalancerPolicyTypesWithContext(_a0 context.Context, _a1 *elb.DescribeLoadBalancerPolicyTypesInput, _a2 ...request.Option) (*elb.DescribeLoadBalancerPolicyTypesOutput, 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 *elb.DescribeLoadBalancerPolicyTypesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeLoadBalancerPolicyTypesInput, ...request.Option) *elb.DescribeLoadBalancerPolicyTypesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancerPolicyTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancers provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancers(_a0 *elb.DescribeLoadBalancersInput) (*elb.DescribeLoadBalancersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeLoadBalancersOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeLoadBalancersInput) *elb.DescribeLoadBalancersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancersOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeELB) DescribeLoadBalancersPages(_a0 *elb.DescribeLoadBalancersInput, _a1 func(*elb.DescribeLoadBalancersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeLoadBalancersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeELB) DescribeLoadBalancersPagesWithContext(_a0 context.Context, _a1 *elb.DescribeLoadBalancersInput, _a2 func(*elb.DescribeLoadBalancersOutput, 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, *elb.DescribeLoadBalancersInput, func(*elb.DescribeLoadBalancersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeLoadBalancersRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeLoadBalancersRequest(_a0 *elb.DescribeLoadBalancersInput) (*request.Request, *elb.DescribeLoadBalancersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeLoadBalancersOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeLoadBalancersInput) *elb.DescribeLoadBalancersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeLoadBalancersOutput)
		}
	}

	return r0, r1
}

// DescribeLoadBalancersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeLoadBalancersWithContext(_a0 context.Context, _a1 *elb.DescribeLoadBalancersInput, _a2 ...request.Option) (*elb.DescribeLoadBalancersOutput, 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 *elb.DescribeLoadBalancersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeLoadBalancersInput, ...request.Option) *elb.DescribeLoadBalancersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeLoadBalancersOutput)
		}
	}

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

	return r0, r1
}

// DescribeTags provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeTags(_a0 *elb.DescribeTagsInput) (*elb.DescribeTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DescribeTagsOutput
	if rf, ok := ret.Get(0).(func(*elb.DescribeTagsInput) *elb.DescribeTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeTagsOutput)
		}
	}

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

	return r0, r1
}

// DescribeTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DescribeTagsRequest(_a0 *elb.DescribeTagsInput) (*request.Request, *elb.DescribeTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DescribeTagsOutput
	if rf, ok := ret.Get(1).(func(*elb.DescribeTagsInput) *elb.DescribeTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DescribeTagsOutput)
		}
	}

	return r0, r1
}

// DescribeTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DescribeTagsWithContext(_a0 context.Context, _a1 *elb.DescribeTagsInput, _a2 ...request.Option) (*elb.DescribeTagsOutput, 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 *elb.DescribeTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DescribeTagsInput, ...request.Option) *elb.DescribeTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DescribeTagsOutput)
		}
	}

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

	return r0, r1
}

// DetachLoadBalancerFromSubnets provides a mock function with given fields: _a0
func (_m *MockFakeELB) DetachLoadBalancerFromSubnets(_a0 *elb.DetachLoadBalancerFromSubnetsInput) (*elb.DetachLoadBalancerFromSubnetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DetachLoadBalancerFromSubnetsOutput
	if rf, ok := ret.Get(0).(func(*elb.DetachLoadBalancerFromSubnetsInput) *elb.DetachLoadBalancerFromSubnetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DetachLoadBalancerFromSubnetsOutput)
		}
	}

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

	return r0, r1
}

// DetachLoadBalancerFromSubnetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DetachLoadBalancerFromSubnetsRequest(_a0 *elb.DetachLoadBalancerFromSubnetsInput) (*request.Request, *elb.DetachLoadBalancerFromSubnetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DetachLoadBalancerFromSubnetsOutput
	if rf, ok := ret.Get(1).(func(*elb.DetachLoadBalancerFromSubnetsInput) *elb.DetachLoadBalancerFromSubnetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DetachLoadBalancerFromSubnetsOutput)
		}
	}

	return r0, r1
}

// DetachLoadBalancerFromSubnetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DetachLoadBalancerFromSubnetsWithContext(_a0 context.Context, _a1 *elb.DetachLoadBalancerFromSubnetsInput, _a2 ...request.Option) (*elb.DetachLoadBalancerFromSubnetsOutput, 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 *elb.DetachLoadBalancerFromSubnetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DetachLoadBalancerFromSubnetsInput, ...request.Option) *elb.DetachLoadBalancerFromSubnetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DetachLoadBalancerFromSubnetsOutput)
		}
	}

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

	return r0, r1
}

// DisableAvailabilityZonesForLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) DisableAvailabilityZonesForLoadBalancer(_a0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.DisableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.DisableAvailabilityZonesForLoadBalancerInput) *elb.DisableAvailabilityZonesForLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// DisableAvailabilityZonesForLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) DisableAvailabilityZonesForLoadBalancerRequest(_a0 *elb.DisableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.DisableAvailabilityZonesForLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.DisableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.DisableAvailabilityZonesForLoadBalancerInput) *elb.DisableAvailabilityZonesForLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
		}
	}

	return r0, r1
}

// DisableAvailabilityZonesForLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) DisableAvailabilityZonesForLoadBalancerWithContext(_a0 context.Context, _a1 *elb.DisableAvailabilityZonesForLoadBalancerInput, _a2 ...request.Option) (*elb.DisableAvailabilityZonesForLoadBalancerOutput, 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 *elb.DisableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.DisableAvailabilityZonesForLoadBalancerInput, ...request.Option) *elb.DisableAvailabilityZonesForLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.DisableAvailabilityZonesForLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// EnableAvailabilityZonesForLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) EnableAvailabilityZonesForLoadBalancer(_a0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.EnableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.EnableAvailabilityZonesForLoadBalancerInput) *elb.EnableAvailabilityZonesForLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// EnableAvailabilityZonesForLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) EnableAvailabilityZonesForLoadBalancerRequest(_a0 *elb.EnableAvailabilityZonesForLoadBalancerInput) (*request.Request, *elb.EnableAvailabilityZonesForLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.EnableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.EnableAvailabilityZonesForLoadBalancerInput) *elb.EnableAvailabilityZonesForLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
		}
	}

	return r0, r1
}

// EnableAvailabilityZonesForLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) EnableAvailabilityZonesForLoadBalancerWithContext(_a0 context.Context, _a1 *elb.EnableAvailabilityZonesForLoadBalancerInput, _a2 ...request.Option) (*elb.EnableAvailabilityZonesForLoadBalancerOutput, 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 *elb.EnableAvailabilityZonesForLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.EnableAvailabilityZonesForLoadBalancerInput, ...request.Option) *elb.EnableAvailabilityZonesForLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.EnableAvailabilityZonesForLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// ModifyLoadBalancerAttributes provides a mock function with given fields: _a0
func (_m *MockFakeELB) ModifyLoadBalancerAttributes(_a0 *elb.ModifyLoadBalancerAttributesInput) (*elb.ModifyLoadBalancerAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.ModifyLoadBalancerAttributesOutput
	if rf, ok := ret.Get(0).(func(*elb.ModifyLoadBalancerAttributesInput) *elb.ModifyLoadBalancerAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ModifyLoadBalancerAttributesOutput)
		}
	}

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

	return r0, r1
}

// ModifyLoadBalancerAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) ModifyLoadBalancerAttributesRequest(_a0 *elb.ModifyLoadBalancerAttributesInput) (*request.Request, *elb.ModifyLoadBalancerAttributesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.ModifyLoadBalancerAttributesOutput
	if rf, ok := ret.Get(1).(func(*elb.ModifyLoadBalancerAttributesInput) *elb.ModifyLoadBalancerAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.ModifyLoadBalancerAttributesOutput)
		}
	}

	return r0, r1
}

// ModifyLoadBalancerAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) ModifyLoadBalancerAttributesWithContext(_a0 context.Context, _a1 *elb.ModifyLoadBalancerAttributesInput, _a2 ...request.Option) (*elb.ModifyLoadBalancerAttributesOutput, 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 *elb.ModifyLoadBalancerAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.ModifyLoadBalancerAttributesInput, ...request.Option) *elb.ModifyLoadBalancerAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.ModifyLoadBalancerAttributesOutput)
		}
	}

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

	return r0, r1
}

// RegisterInstancesWithLoadBalancer provides a mock function with given fields: _a0
func (_m *MockFakeELB) RegisterInstancesWithLoadBalancer(_a0 *elb.RegisterInstancesWithLoadBalancerInput) (*elb.RegisterInstancesWithLoadBalancerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.RegisterInstancesWithLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(*elb.RegisterInstancesWithLoadBalancerInput) *elb.RegisterInstancesWithLoadBalancerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.RegisterInstancesWithLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// RegisterInstancesWithLoadBalancerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) RegisterInstancesWithLoadBalancerRequest(_a0 *elb.RegisterInstancesWithLoadBalancerInput) (*request.Request, *elb.RegisterInstancesWithLoadBalancerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.RegisterInstancesWithLoadBalancerOutput
	if rf, ok := ret.Get(1).(func(*elb.RegisterInstancesWithLoadBalancerInput) *elb.RegisterInstancesWithLoadBalancerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.RegisterInstancesWithLoadBalancerOutput)
		}
	}

	return r0, r1
}

// RegisterInstancesWithLoadBalancerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) RegisterInstancesWithLoadBalancerWithContext(_a0 context.Context, _a1 *elb.RegisterInstancesWithLoadBalancerInput, _a2 ...request.Option) (*elb.RegisterInstancesWithLoadBalancerOutput, 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 *elb.RegisterInstancesWithLoadBalancerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.RegisterInstancesWithLoadBalancerInput, ...request.Option) *elb.RegisterInstancesWithLoadBalancerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.RegisterInstancesWithLoadBalancerOutput)
		}
	}

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

	return r0, r1
}

// RemoveTags provides a mock function with given fields: _a0
func (_m *MockFakeELB) RemoveTags(_a0 *elb.RemoveTagsInput) (*elb.RemoveTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.RemoveTagsOutput
	if rf, ok := ret.Get(0).(func(*elb.RemoveTagsInput) *elb.RemoveTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.RemoveTagsOutput)
		}
	}

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

	return r0, r1
}

// RemoveTagsRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) RemoveTagsRequest(_a0 *elb.RemoveTagsInput) (*request.Request, *elb.RemoveTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.RemoveTagsOutput
	if rf, ok := ret.Get(1).(func(*elb.RemoveTagsInput) *elb.RemoveTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.RemoveTagsOutput)
		}
	}

	return r0, r1
}

// RemoveTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) RemoveTagsWithContext(_a0 context.Context, _a1 *elb.RemoveTagsInput, _a2 ...request.Option) (*elb.RemoveTagsOutput, 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 *elb.RemoveTagsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.RemoveTagsInput, ...request.Option) *elb.RemoveTagsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.RemoveTagsOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerListenerSSLCertificate provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerListenerSSLCertificate(_a0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*elb.SetLoadBalancerListenerSSLCertificateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.SetLoadBalancerListenerSSLCertificateOutput
	if rf, ok := ret.Get(0).(func(*elb.SetLoadBalancerListenerSSLCertificateInput) *elb.SetLoadBalancerListenerSSLCertificateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerListenerSSLCertificateOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerListenerSSLCertificateRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerListenerSSLCertificateRequest(_a0 *elb.SetLoadBalancerListenerSSLCertificateInput) (*request.Request, *elb.SetLoadBalancerListenerSSLCertificateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.SetLoadBalancerListenerSSLCertificateOutput
	if rf, ok := ret.Get(1).(func(*elb.SetLoadBalancerListenerSSLCertificateInput) *elb.SetLoadBalancerListenerSSLCertificateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.SetLoadBalancerListenerSSLCertificateOutput)
		}
	}

	return r0, r1
}

// SetLoadBalancerListenerSSLCertificateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) SetLoadBalancerListenerSSLCertificateWithContext(_a0 context.Context, _a1 *elb.SetLoadBalancerListenerSSLCertificateInput, _a2 ...request.Option) (*elb.SetLoadBalancerListenerSSLCertificateOutput, 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 *elb.SetLoadBalancerListenerSSLCertificateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.SetLoadBalancerListenerSSLCertificateInput, ...request.Option) *elb.SetLoadBalancerListenerSSLCertificateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerListenerSSLCertificateOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerPoliciesForBackendServer provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerPoliciesForBackendServer(_a0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.SetLoadBalancerPoliciesForBackendServerOutput
	if rf, ok := ret.Get(0).(func(*elb.SetLoadBalancerPoliciesForBackendServerInput) *elb.SetLoadBalancerPoliciesForBackendServerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerPoliciesForBackendServerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerPoliciesForBackendServerRequest(_a0 *elb.SetLoadBalancerPoliciesForBackendServerInput) (*request.Request, *elb.SetLoadBalancerPoliciesForBackendServerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.SetLoadBalancerPoliciesForBackendServerOutput
	if rf, ok := ret.Get(1).(func(*elb.SetLoadBalancerPoliciesForBackendServerInput) *elb.SetLoadBalancerPoliciesForBackendServerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
		}
	}

	return r0, r1
}

// SetLoadBalancerPoliciesForBackendServerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) SetLoadBalancerPoliciesForBackendServerWithContext(_a0 context.Context, _a1 *elb.SetLoadBalancerPoliciesForBackendServerInput, _a2 ...request.Option) (*elb.SetLoadBalancerPoliciesForBackendServerOutput, 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 *elb.SetLoadBalancerPoliciesForBackendServerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.SetLoadBalancerPoliciesForBackendServerInput, ...request.Option) *elb.SetLoadBalancerPoliciesForBackendServerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerPoliciesForBackendServerOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerPoliciesOfListener provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerPoliciesOfListener(_a0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*elb.SetLoadBalancerPoliciesOfListenerOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elb.SetLoadBalancerPoliciesOfListenerOutput
	if rf, ok := ret.Get(0).(func(*elb.SetLoadBalancerPoliciesOfListenerInput) *elb.SetLoadBalancerPoliciesOfListenerOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerPoliciesOfListenerOutput)
		}
	}

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

	return r0, r1
}

// SetLoadBalancerPoliciesOfListenerRequest provides a mock function with given fields: _a0
func (_m *MockFakeELB) SetLoadBalancerPoliciesOfListenerRequest(_a0 *elb.SetLoadBalancerPoliciesOfListenerInput) (*request.Request, *elb.SetLoadBalancerPoliciesOfListenerOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elb.SetLoadBalancerPoliciesOfListenerOutput
	if rf, ok := ret.Get(1).(func(*elb.SetLoadBalancerPoliciesOfListenerInput) *elb.SetLoadBalancerPoliciesOfListenerOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elb.SetLoadBalancerPoliciesOfListenerOutput)
		}
	}

	return r0, r1
}

// SetLoadBalancerPoliciesOfListenerWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) SetLoadBalancerPoliciesOfListenerWithContext(_a0 context.Context, _a1 *elb.SetLoadBalancerPoliciesOfListenerInput, _a2 ...request.Option) (*elb.SetLoadBalancerPoliciesOfListenerOutput, 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 *elb.SetLoadBalancerPoliciesOfListenerOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elb.SetLoadBalancerPoliciesOfListenerInput, ...request.Option) *elb.SetLoadBalancerPoliciesOfListenerOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elb.SetLoadBalancerPoliciesOfListenerOutput)
		}
	}

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

	return r0, r1
}

// WaitUntilAnyInstanceInService provides a mock function with given fields: _a0
func (_m *MockFakeELB) WaitUntilAnyInstanceInService(_a0 *elb.DescribeInstanceHealthInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elb.DescribeInstanceHealthInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilAnyInstanceInServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) WaitUntilAnyInstanceInServiceWithContext(_a0 context.Context, _a1 *elb.DescribeInstanceHealthInput, _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, *elb.DescribeInstanceHealthInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceDeregistered provides a mock function with given fields: _a0
func (_m *MockFakeELB) WaitUntilInstanceDeregistered(_a0 *elb.DescribeInstanceHealthInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elb.DescribeInstanceHealthInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceDeregisteredWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) WaitUntilInstanceDeregisteredWithContext(_a0 context.Context, _a1 *elb.DescribeInstanceHealthInput, _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, *elb.DescribeInstanceHealthInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceInService provides a mock function with given fields: _a0
func (_m *MockFakeELB) WaitUntilInstanceInService(_a0 *elb.DescribeInstanceHealthInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elb.DescribeInstanceHealthInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilInstanceInServiceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeELB) WaitUntilInstanceInServiceWithContext(_a0 context.Context, _a1 *elb.DescribeInstanceHealthInput, _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, *elb.DescribeInstanceHealthInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}