// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

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"
)

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

// AddTags provides a mock function with given fields: _a0
func (_m *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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 *ELBAPI) 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
}
