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

package mocks

import (
	autoscaling "github.com/aws/aws-sdk-go/service/autoscaling"

	context "context"

	mock "github.com/stretchr/testify/mock"

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

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

// AttachInstances provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachInstances(_a0 *autoscaling.AttachInstancesInput) (*autoscaling.AttachInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.AttachInstancesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.AttachInstancesInput) *autoscaling.AttachInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.AttachInstancesOutput)
		}
	}

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

	return r0, r1
}

// AttachInstancesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachInstancesRequest(_a0 *autoscaling.AttachInstancesInput) (*request.Request, *autoscaling.AttachInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.AttachInstancesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.AttachInstancesInput) *autoscaling.AttachInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.AttachInstancesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// AttachLoadBalancerTargetGroups provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachLoadBalancerTargetGroups(_a0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.AttachLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.AttachLoadBalancerTargetGroupsInput) *autoscaling.AttachLoadBalancerTargetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.AttachLoadBalancerTargetGroupsOutput)
		}
	}

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

	return r0, r1
}

// AttachLoadBalancerTargetGroupsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachLoadBalancerTargetGroupsRequest(_a0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.AttachLoadBalancerTargetGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.AttachLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.AttachLoadBalancerTargetGroupsInput) *autoscaling.AttachLoadBalancerTargetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.AttachLoadBalancerTargetGroupsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// AttachLoadBalancers provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachLoadBalancers(_a0 *autoscaling.AttachLoadBalancersInput) (*autoscaling.AttachLoadBalancersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.AttachLoadBalancersOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.AttachLoadBalancersInput) *autoscaling.AttachLoadBalancersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.AttachLoadBalancersOutput)
		}
	}

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

	return r0, r1
}

// AttachLoadBalancersRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) AttachLoadBalancersRequest(_a0 *autoscaling.AttachLoadBalancersInput) (*request.Request, *autoscaling.AttachLoadBalancersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.AttachLoadBalancersOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.AttachLoadBalancersInput) *autoscaling.AttachLoadBalancersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.AttachLoadBalancersOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// BatchDeleteScheduledAction provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) BatchDeleteScheduledAction(_a0 *autoscaling.BatchDeleteScheduledActionInput) (*autoscaling.BatchDeleteScheduledActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.BatchDeleteScheduledActionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.BatchDeleteScheduledActionInput) *autoscaling.BatchDeleteScheduledActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.BatchDeleteScheduledActionOutput)
		}
	}

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

	return r0, r1
}

// BatchDeleteScheduledActionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) BatchDeleteScheduledActionRequest(_a0 *autoscaling.BatchDeleteScheduledActionInput) (*request.Request, *autoscaling.BatchDeleteScheduledActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.BatchDeleteScheduledActionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.BatchDeleteScheduledActionInput) *autoscaling.BatchDeleteScheduledActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.BatchDeleteScheduledActionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// BatchPutScheduledUpdateGroupAction provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) BatchPutScheduledUpdateGroupAction(_a0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*autoscaling.BatchPutScheduledUpdateGroupActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.BatchPutScheduledUpdateGroupActionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.BatchPutScheduledUpdateGroupActionInput) *autoscaling.BatchPutScheduledUpdateGroupActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.BatchPutScheduledUpdateGroupActionOutput)
		}
	}

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

	return r0, r1
}

// BatchPutScheduledUpdateGroupActionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) BatchPutScheduledUpdateGroupActionRequest(_a0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.BatchPutScheduledUpdateGroupActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.BatchPutScheduledUpdateGroupActionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.BatchPutScheduledUpdateGroupActionInput) *autoscaling.BatchPutScheduledUpdateGroupActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.BatchPutScheduledUpdateGroupActionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// CancelInstanceRefresh provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CancelInstanceRefresh(_a0 *autoscaling.CancelInstanceRefreshInput) (*autoscaling.CancelInstanceRefreshOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.CancelInstanceRefreshOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.CancelInstanceRefreshInput) *autoscaling.CancelInstanceRefreshOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.CancelInstanceRefreshOutput)
		}
	}

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

	return r0, r1
}

// CancelInstanceRefreshRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CancelInstanceRefreshRequest(_a0 *autoscaling.CancelInstanceRefreshInput) (*request.Request, *autoscaling.CancelInstanceRefreshOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.CancelInstanceRefreshOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.CancelInstanceRefreshInput) *autoscaling.CancelInstanceRefreshOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.CancelInstanceRefreshOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// CompleteLifecycleAction provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CompleteLifecycleAction(_a0 *autoscaling.CompleteLifecycleActionInput) (*autoscaling.CompleteLifecycleActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.CompleteLifecycleActionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.CompleteLifecycleActionInput) *autoscaling.CompleteLifecycleActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.CompleteLifecycleActionOutput)
		}
	}

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

	return r0, r1
}

// CompleteLifecycleActionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CompleteLifecycleActionRequest(_a0 *autoscaling.CompleteLifecycleActionInput) (*request.Request, *autoscaling.CompleteLifecycleActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.CompleteLifecycleActionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.CompleteLifecycleActionInput) *autoscaling.CompleteLifecycleActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.CompleteLifecycleActionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// CreateAutoScalingGroup provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateAutoScalingGroup(_a0 *autoscaling.CreateAutoScalingGroupInput) (*autoscaling.CreateAutoScalingGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.CreateAutoScalingGroupOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.CreateAutoScalingGroupInput) *autoscaling.CreateAutoScalingGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.CreateAutoScalingGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateAutoScalingGroupRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateAutoScalingGroupRequest(_a0 *autoscaling.CreateAutoScalingGroupInput) (*request.Request, *autoscaling.CreateAutoScalingGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.CreateAutoScalingGroupOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.CreateAutoScalingGroupInput) *autoscaling.CreateAutoScalingGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.CreateAutoScalingGroupOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// CreateLaunchConfiguration provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateLaunchConfiguration(_a0 *autoscaling.CreateLaunchConfigurationInput) (*autoscaling.CreateLaunchConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.CreateLaunchConfigurationOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.CreateLaunchConfigurationInput) *autoscaling.CreateLaunchConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.CreateLaunchConfigurationOutput)
		}
	}

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

	return r0, r1
}

// CreateLaunchConfigurationRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateLaunchConfigurationRequest(_a0 *autoscaling.CreateLaunchConfigurationInput) (*request.Request, *autoscaling.CreateLaunchConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.CreateLaunchConfigurationOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.CreateLaunchConfigurationInput) *autoscaling.CreateLaunchConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.CreateLaunchConfigurationOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// CreateOrUpdateTags provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateOrUpdateTags(_a0 *autoscaling.CreateOrUpdateTagsInput) (*autoscaling.CreateOrUpdateTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.CreateOrUpdateTagsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.CreateOrUpdateTagsInput) *autoscaling.CreateOrUpdateTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.CreateOrUpdateTagsOutput)
		}
	}

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

	return r0, r1
}

// CreateOrUpdateTagsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) CreateOrUpdateTagsRequest(_a0 *autoscaling.CreateOrUpdateTagsInput) (*request.Request, *autoscaling.CreateOrUpdateTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.CreateOrUpdateTagsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.CreateOrUpdateTagsInput) *autoscaling.CreateOrUpdateTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.CreateOrUpdateTagsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteAutoScalingGroup provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteAutoScalingGroup(_a0 *autoscaling.DeleteAutoScalingGroupInput) (*autoscaling.DeleteAutoScalingGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteAutoScalingGroupOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteAutoScalingGroupInput) *autoscaling.DeleteAutoScalingGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteAutoScalingGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteAutoScalingGroupRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteAutoScalingGroupRequest(_a0 *autoscaling.DeleteAutoScalingGroupInput) (*request.Request, *autoscaling.DeleteAutoScalingGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteAutoScalingGroupOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteAutoScalingGroupInput) *autoscaling.DeleteAutoScalingGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteAutoScalingGroupOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteLaunchConfiguration provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteLaunchConfiguration(_a0 *autoscaling.DeleteLaunchConfigurationInput) (*autoscaling.DeleteLaunchConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteLaunchConfigurationOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteLaunchConfigurationInput) *autoscaling.DeleteLaunchConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteLaunchConfigurationOutput)
		}
	}

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

	return r0, r1
}

// DeleteLaunchConfigurationRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteLaunchConfigurationRequest(_a0 *autoscaling.DeleteLaunchConfigurationInput) (*request.Request, *autoscaling.DeleteLaunchConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteLaunchConfigurationOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteLaunchConfigurationInput) *autoscaling.DeleteLaunchConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteLaunchConfigurationOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteLifecycleHook provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteLifecycleHook(_a0 *autoscaling.DeleteLifecycleHookInput) (*autoscaling.DeleteLifecycleHookOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteLifecycleHookOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteLifecycleHookInput) *autoscaling.DeleteLifecycleHookOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteLifecycleHookOutput)
		}
	}

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

	return r0, r1
}

// DeleteLifecycleHookRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteLifecycleHookRequest(_a0 *autoscaling.DeleteLifecycleHookInput) (*request.Request, *autoscaling.DeleteLifecycleHookOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteLifecycleHookOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteLifecycleHookInput) *autoscaling.DeleteLifecycleHookOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteLifecycleHookOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteNotificationConfiguration provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteNotificationConfiguration(_a0 *autoscaling.DeleteNotificationConfigurationInput) (*autoscaling.DeleteNotificationConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteNotificationConfigurationOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteNotificationConfigurationInput) *autoscaling.DeleteNotificationConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteNotificationConfigurationOutput)
		}
	}

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

	return r0, r1
}

// DeleteNotificationConfigurationRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteNotificationConfigurationRequest(_a0 *autoscaling.DeleteNotificationConfigurationInput) (*request.Request, *autoscaling.DeleteNotificationConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteNotificationConfigurationOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteNotificationConfigurationInput) *autoscaling.DeleteNotificationConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteNotificationConfigurationOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteScheduledAction provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteScheduledAction(_a0 *autoscaling.DeleteScheduledActionInput) (*autoscaling.DeleteScheduledActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteScheduledActionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteScheduledActionInput) *autoscaling.DeleteScheduledActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteScheduledActionOutput)
		}
	}

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

	return r0, r1
}

// DeleteScheduledActionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteScheduledActionRequest(_a0 *autoscaling.DeleteScheduledActionInput) (*request.Request, *autoscaling.DeleteScheduledActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteScheduledActionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteScheduledActionInput) *autoscaling.DeleteScheduledActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteScheduledActionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteTags provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteTags(_a0 *autoscaling.DeleteTagsInput) (*autoscaling.DeleteTagsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteTagsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteTagsInput) *autoscaling.DeleteTagsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteTagsOutput)
		}
	}

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

	return r0, r1
}

// DeleteTagsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteTagsRequest(_a0 *autoscaling.DeleteTagsInput) (*request.Request, *autoscaling.DeleteTagsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteTagsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteTagsInput) *autoscaling.DeleteTagsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteTagsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DeleteWarmPool provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteWarmPool(_a0 *autoscaling.DeleteWarmPoolInput) (*autoscaling.DeleteWarmPoolOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DeleteWarmPoolOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DeleteWarmPoolInput) *autoscaling.DeleteWarmPoolOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DeleteWarmPoolOutput)
		}
	}

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

	return r0, r1
}

// DeleteWarmPoolRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DeleteWarmPoolRequest(_a0 *autoscaling.DeleteWarmPoolInput) (*request.Request, *autoscaling.DeleteWarmPoolOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DeleteWarmPoolOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DeleteWarmPoolInput) *autoscaling.DeleteWarmPoolOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DeleteWarmPoolOutput)
		}
	}

	return r0, r1
}

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

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *autoscaling.DeleteWarmPoolInput, ...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 *AutoScalingAPI) DescribeAccountLimits(_a0 *autoscaling.DescribeAccountLimitsInput) (*autoscaling.DescribeAccountLimitsOutput, error) {
	ret := _m.Called(_a0)

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*autoscaling.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 *AutoScalingAPI) DescribeAccountLimitsRequest(_a0 *autoscaling.DescribeAccountLimitsInput) (*request.Request, *autoscaling.DescribeAccountLimitsOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeAdjustmentTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAdjustmentTypes(_a0 *autoscaling.DescribeAdjustmentTypesInput) (*autoscaling.DescribeAdjustmentTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeAdjustmentTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeAdjustmentTypesInput) *autoscaling.DescribeAdjustmentTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeAdjustmentTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAdjustmentTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAdjustmentTypesRequest(_a0 *autoscaling.DescribeAdjustmentTypesInput) (*request.Request, *autoscaling.DescribeAdjustmentTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeAdjustmentTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeAdjustmentTypesInput) *autoscaling.DescribeAdjustmentTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeAdjustmentTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeAutoScalingGroups provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingGroups(_a0 *autoscaling.DescribeAutoScalingGroupsInput) (*autoscaling.DescribeAutoScalingGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeAutoScalingGroupsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeAutoScalingGroupsInput) *autoscaling.DescribeAutoScalingGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeAutoScalingGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutoScalingGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeAutoScalingGroupsPages(_a0 *autoscaling.DescribeAutoScalingGroupsInput, _a1 func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeAutoScalingGroupsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingGroupsRequest(_a0 *autoscaling.DescribeAutoScalingGroupsInput) (*request.Request, *autoscaling.DescribeAutoScalingGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeAutoScalingGroupsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeAutoScalingGroupsInput) *autoscaling.DescribeAutoScalingGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeAutoScalingGroupsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeAutoScalingInstances provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingInstances(_a0 *autoscaling.DescribeAutoScalingInstancesInput) (*autoscaling.DescribeAutoScalingInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeAutoScalingInstancesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeAutoScalingInstancesInput) *autoscaling.DescribeAutoScalingInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeAutoScalingInstancesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutoScalingInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeAutoScalingInstancesPages(_a0 *autoscaling.DescribeAutoScalingInstancesInput, _a1 func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeAutoScalingInstancesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingInstancesRequest(_a0 *autoscaling.DescribeAutoScalingInstancesInput) (*request.Request, *autoscaling.DescribeAutoScalingInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeAutoScalingInstancesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeAutoScalingInstancesInput) *autoscaling.DescribeAutoScalingInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeAutoScalingInstancesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeAutoScalingNotificationTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingNotificationTypes(_a0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeAutoScalingNotificationTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeAutoScalingNotificationTypesInput) *autoscaling.DescribeAutoScalingNotificationTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeAutoScalingNotificationTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeAutoScalingNotificationTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeAutoScalingNotificationTypesRequest(_a0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*request.Request, *autoscaling.DescribeAutoScalingNotificationTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeAutoScalingNotificationTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeAutoScalingNotificationTypesInput) *autoscaling.DescribeAutoScalingNotificationTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeAutoScalingNotificationTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeInstanceRefreshes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeInstanceRefreshes(_a0 *autoscaling.DescribeInstanceRefreshesInput) (*autoscaling.DescribeInstanceRefreshesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeInstanceRefreshesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeInstanceRefreshesInput) *autoscaling.DescribeInstanceRefreshesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeInstanceRefreshesOutput)
		}
	}

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

	return r0, r1
}

// DescribeInstanceRefreshesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeInstanceRefreshesRequest(_a0 *autoscaling.DescribeInstanceRefreshesInput) (*request.Request, *autoscaling.DescribeInstanceRefreshesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeInstanceRefreshesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeInstanceRefreshesInput) *autoscaling.DescribeInstanceRefreshesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeInstanceRefreshesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeLaunchConfigurations provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLaunchConfigurations(_a0 *autoscaling.DescribeLaunchConfigurationsInput) (*autoscaling.DescribeLaunchConfigurationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeLaunchConfigurationsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeLaunchConfigurationsInput) *autoscaling.DescribeLaunchConfigurationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeLaunchConfigurationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLaunchConfigurationsPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeLaunchConfigurationsPages(_a0 *autoscaling.DescribeLaunchConfigurationsInput, _a1 func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeLaunchConfigurationsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLaunchConfigurationsRequest(_a0 *autoscaling.DescribeLaunchConfigurationsInput) (*request.Request, *autoscaling.DescribeLaunchConfigurationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeLaunchConfigurationsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeLaunchConfigurationsInput) *autoscaling.DescribeLaunchConfigurationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeLaunchConfigurationsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeLifecycleHookTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLifecycleHookTypes(_a0 *autoscaling.DescribeLifecycleHookTypesInput) (*autoscaling.DescribeLifecycleHookTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeLifecycleHookTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeLifecycleHookTypesInput) *autoscaling.DescribeLifecycleHookTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeLifecycleHookTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeLifecycleHookTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLifecycleHookTypesRequest(_a0 *autoscaling.DescribeLifecycleHookTypesInput) (*request.Request, *autoscaling.DescribeLifecycleHookTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeLifecycleHookTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeLifecycleHookTypesInput) *autoscaling.DescribeLifecycleHookTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeLifecycleHookTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeLifecycleHooks provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLifecycleHooks(_a0 *autoscaling.DescribeLifecycleHooksInput) (*autoscaling.DescribeLifecycleHooksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeLifecycleHooksOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeLifecycleHooksInput) *autoscaling.DescribeLifecycleHooksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeLifecycleHooksOutput)
		}
	}

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

	return r0, r1
}

// DescribeLifecycleHooksRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLifecycleHooksRequest(_a0 *autoscaling.DescribeLifecycleHooksInput) (*request.Request, *autoscaling.DescribeLifecycleHooksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeLifecycleHooksOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeLifecycleHooksInput) *autoscaling.DescribeLifecycleHooksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeLifecycleHooksOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeLoadBalancerTargetGroups provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLoadBalancerTargetGroups(_a0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeLoadBalancerTargetGroupsInput) *autoscaling.DescribeLoadBalancerTargetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeLoadBalancerTargetGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeLoadBalancerTargetGroupsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeLoadBalancerTargetGroupsRequest(_a0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DescribeLoadBalancerTargetGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeLoadBalancerTargetGroupsInput) *autoscaling.DescribeLoadBalancerTargetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeLoadBalancerTargetGroupsOutput)
		}
	}

	return r0, r1
}

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

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *autoscaling.DescribeLoadBalancerTargetGroupsInput, ...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 *AutoScalingAPI) DescribeLoadBalancers(_a0 *autoscaling.DescribeLoadBalancersInput) (*autoscaling.DescribeLoadBalancersOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeMetricCollectionTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeMetricCollectionTypes(_a0 *autoscaling.DescribeMetricCollectionTypesInput) (*autoscaling.DescribeMetricCollectionTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeMetricCollectionTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeMetricCollectionTypesInput) *autoscaling.DescribeMetricCollectionTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeMetricCollectionTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeMetricCollectionTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeMetricCollectionTypesRequest(_a0 *autoscaling.DescribeMetricCollectionTypesInput) (*request.Request, *autoscaling.DescribeMetricCollectionTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeMetricCollectionTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeMetricCollectionTypesInput) *autoscaling.DescribeMetricCollectionTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeMetricCollectionTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeNotificationConfigurations provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeNotificationConfigurations(_a0 *autoscaling.DescribeNotificationConfigurationsInput) (*autoscaling.DescribeNotificationConfigurationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeNotificationConfigurationsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeNotificationConfigurationsInput) *autoscaling.DescribeNotificationConfigurationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeNotificationConfigurationsOutput)
		}
	}

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

	return r0, r1
}

// DescribeNotificationConfigurationsPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeNotificationConfigurationsPages(_a0 *autoscaling.DescribeNotificationConfigurationsInput, _a1 func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeNotificationConfigurationsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeNotificationConfigurationsRequest(_a0 *autoscaling.DescribeNotificationConfigurationsInput) (*request.Request, *autoscaling.DescribeNotificationConfigurationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeNotificationConfigurationsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeNotificationConfigurationsInput) *autoscaling.DescribeNotificationConfigurationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeNotificationConfigurationsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribePolicies provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribePolicies(_a0 *autoscaling.DescribePoliciesInput) (*autoscaling.DescribePoliciesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribePoliciesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribePoliciesInput) *autoscaling.DescribePoliciesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribePoliciesOutput)
		}
	}

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

	return r0, r1
}

// DescribePoliciesPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribePoliciesPages(_a0 *autoscaling.DescribePoliciesInput, _a1 func(*autoscaling.DescribePoliciesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribePoliciesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribePoliciesRequest(_a0 *autoscaling.DescribePoliciesInput) (*request.Request, *autoscaling.DescribePoliciesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribePoliciesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribePoliciesInput) *autoscaling.DescribePoliciesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribePoliciesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeScalingActivities provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScalingActivities(_a0 *autoscaling.DescribeScalingActivitiesInput) (*autoscaling.DescribeScalingActivitiesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeScalingActivitiesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeScalingActivitiesInput) *autoscaling.DescribeScalingActivitiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeScalingActivitiesOutput)
		}
	}

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

	return r0, r1
}

// DescribeScalingActivitiesPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeScalingActivitiesPages(_a0 *autoscaling.DescribeScalingActivitiesInput, _a1 func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeScalingActivitiesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScalingActivitiesRequest(_a0 *autoscaling.DescribeScalingActivitiesInput) (*request.Request, *autoscaling.DescribeScalingActivitiesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeScalingActivitiesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeScalingActivitiesInput) *autoscaling.DescribeScalingActivitiesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeScalingActivitiesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeScalingProcessTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScalingProcessTypes(_a0 *autoscaling.DescribeScalingProcessTypesInput) (*autoscaling.DescribeScalingProcessTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeScalingProcessTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeScalingProcessTypesInput) *autoscaling.DescribeScalingProcessTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeScalingProcessTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeScalingProcessTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScalingProcessTypesRequest(_a0 *autoscaling.DescribeScalingProcessTypesInput) (*request.Request, *autoscaling.DescribeScalingProcessTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeScalingProcessTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeScalingProcessTypesInput) *autoscaling.DescribeScalingProcessTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeScalingProcessTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeScheduledActions provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScheduledActions(_a0 *autoscaling.DescribeScheduledActionsInput) (*autoscaling.DescribeScheduledActionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeScheduledActionsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeScheduledActionsInput) *autoscaling.DescribeScheduledActionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeScheduledActionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeScheduledActionsPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeScheduledActionsPages(_a0 *autoscaling.DescribeScheduledActionsInput, _a1 func(*autoscaling.DescribeScheduledActionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeScheduledActionsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeScheduledActionsRequest(_a0 *autoscaling.DescribeScheduledActionsInput) (*request.Request, *autoscaling.DescribeScheduledActionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeScheduledActionsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeScheduledActionsInput) *autoscaling.DescribeScheduledActionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeScheduledActionsOutput)
		}
	}

	return r0, r1
}

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

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *autoscaling.DescribeScheduledActionsInput, ...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 *AutoScalingAPI) DescribeTags(_a0 *autoscaling.DescribeTagsInput) (*autoscaling.DescribeTagsOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribeTagsPages provides a mock function with given fields: _a0, _a1
func (_m *AutoScalingAPI) DescribeTagsPages(_a0 *autoscaling.DescribeTagsInput, _a1 func(*autoscaling.DescribeTagsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

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

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

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

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeTerminationPolicyTypes provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeTerminationPolicyTypes(_a0 *autoscaling.DescribeTerminationPolicyTypesInput) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeTerminationPolicyTypesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeTerminationPolicyTypesInput) *autoscaling.DescribeTerminationPolicyTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeTerminationPolicyTypesOutput)
		}
	}

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

	return r0, r1
}

// DescribeTerminationPolicyTypesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeTerminationPolicyTypesRequest(_a0 *autoscaling.DescribeTerminationPolicyTypesInput) (*request.Request, *autoscaling.DescribeTerminationPolicyTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeTerminationPolicyTypesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeTerminationPolicyTypesInput) *autoscaling.DescribeTerminationPolicyTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeTerminationPolicyTypesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeWarmPool provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeWarmPool(_a0 *autoscaling.DescribeWarmPoolInput) (*autoscaling.DescribeWarmPoolOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DescribeWarmPoolOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DescribeWarmPoolInput) *autoscaling.DescribeWarmPoolOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DescribeWarmPoolOutput)
		}
	}

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

	return r0, r1
}

// DescribeWarmPoolRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DescribeWarmPoolRequest(_a0 *autoscaling.DescribeWarmPoolInput) (*request.Request, *autoscaling.DescribeWarmPoolOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DescribeWarmPoolOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DescribeWarmPoolInput) *autoscaling.DescribeWarmPoolOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DescribeWarmPoolOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DetachInstances provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachInstances(_a0 *autoscaling.DetachInstancesInput) (*autoscaling.DetachInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DetachInstancesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DetachInstancesInput) *autoscaling.DetachInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DetachInstancesOutput)
		}
	}

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

	return r0, r1
}

// DetachInstancesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachInstancesRequest(_a0 *autoscaling.DetachInstancesInput) (*request.Request, *autoscaling.DetachInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DetachInstancesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DetachInstancesInput) *autoscaling.DetachInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DetachInstancesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DetachLoadBalancerTargetGroups provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachLoadBalancerTargetGroups(_a0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DetachLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DetachLoadBalancerTargetGroupsInput) *autoscaling.DetachLoadBalancerTargetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DetachLoadBalancerTargetGroupsOutput)
		}
	}

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

	return r0, r1
}

// DetachLoadBalancerTargetGroupsRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachLoadBalancerTargetGroupsRequest(_a0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DetachLoadBalancerTargetGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DetachLoadBalancerTargetGroupsOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DetachLoadBalancerTargetGroupsInput) *autoscaling.DetachLoadBalancerTargetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DetachLoadBalancerTargetGroupsOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DetachLoadBalancers provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachLoadBalancers(_a0 *autoscaling.DetachLoadBalancersInput) (*autoscaling.DetachLoadBalancersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DetachLoadBalancersOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DetachLoadBalancersInput) *autoscaling.DetachLoadBalancersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DetachLoadBalancersOutput)
		}
	}

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

	return r0, r1
}

// DetachLoadBalancersRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DetachLoadBalancersRequest(_a0 *autoscaling.DetachLoadBalancersInput) (*request.Request, *autoscaling.DetachLoadBalancersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DetachLoadBalancersOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DetachLoadBalancersInput) *autoscaling.DetachLoadBalancersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DetachLoadBalancersOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// DisableMetricsCollection provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DisableMetricsCollection(_a0 *autoscaling.DisableMetricsCollectionInput) (*autoscaling.DisableMetricsCollectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.DisableMetricsCollectionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.DisableMetricsCollectionInput) *autoscaling.DisableMetricsCollectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.DisableMetricsCollectionOutput)
		}
	}

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

	return r0, r1
}

// DisableMetricsCollectionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) DisableMetricsCollectionRequest(_a0 *autoscaling.DisableMetricsCollectionInput) (*request.Request, *autoscaling.DisableMetricsCollectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.DisableMetricsCollectionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.DisableMetricsCollectionInput) *autoscaling.DisableMetricsCollectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.DisableMetricsCollectionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// EnableMetricsCollection provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) EnableMetricsCollection(_a0 *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.EnableMetricsCollectionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.EnableMetricsCollectionInput) *autoscaling.EnableMetricsCollectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.EnableMetricsCollectionOutput)
		}
	}

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

	return r0, r1
}

// EnableMetricsCollectionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) EnableMetricsCollectionRequest(_a0 *autoscaling.EnableMetricsCollectionInput) (*request.Request, *autoscaling.EnableMetricsCollectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.EnableMetricsCollectionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.EnableMetricsCollectionInput) *autoscaling.EnableMetricsCollectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.EnableMetricsCollectionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// EnterStandby provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) EnterStandby(_a0 *autoscaling.EnterStandbyInput) (*autoscaling.EnterStandbyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.EnterStandbyOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.EnterStandbyInput) *autoscaling.EnterStandbyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.EnterStandbyOutput)
		}
	}

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

	return r0, r1
}

// EnterStandbyRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) EnterStandbyRequest(_a0 *autoscaling.EnterStandbyInput) (*request.Request, *autoscaling.EnterStandbyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.EnterStandbyOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.EnterStandbyInput) *autoscaling.EnterStandbyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.EnterStandbyOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// ExecutePolicy provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ExecutePolicy(_a0 *autoscaling.ExecutePolicyInput) (*autoscaling.ExecutePolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.ExecutePolicyOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.ExecutePolicyInput) *autoscaling.ExecutePolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.ExecutePolicyOutput)
		}
	}

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

	return r0, r1
}

// ExecutePolicyRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ExecutePolicyRequest(_a0 *autoscaling.ExecutePolicyInput) (*request.Request, *autoscaling.ExecutePolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.ExecutePolicyOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.ExecutePolicyInput) *autoscaling.ExecutePolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.ExecutePolicyOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// ExitStandby provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ExitStandby(_a0 *autoscaling.ExitStandbyInput) (*autoscaling.ExitStandbyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.ExitStandbyOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.ExitStandbyInput) *autoscaling.ExitStandbyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.ExitStandbyOutput)
		}
	}

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

	return r0, r1
}

// ExitStandbyRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ExitStandbyRequest(_a0 *autoscaling.ExitStandbyInput) (*request.Request, *autoscaling.ExitStandbyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.ExitStandbyOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.ExitStandbyInput) *autoscaling.ExitStandbyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.ExitStandbyOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// GetPredictiveScalingForecast provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) GetPredictiveScalingForecast(_a0 *autoscaling.GetPredictiveScalingForecastInput) (*autoscaling.GetPredictiveScalingForecastOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.GetPredictiveScalingForecastOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.GetPredictiveScalingForecastInput) *autoscaling.GetPredictiveScalingForecastOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.GetPredictiveScalingForecastOutput)
		}
	}

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

	return r0, r1
}

// GetPredictiveScalingForecastRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) GetPredictiveScalingForecastRequest(_a0 *autoscaling.GetPredictiveScalingForecastInput) (*request.Request, *autoscaling.GetPredictiveScalingForecastOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.GetPredictiveScalingForecastOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.GetPredictiveScalingForecastInput) *autoscaling.GetPredictiveScalingForecastOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.GetPredictiveScalingForecastOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// PutLifecycleHook provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutLifecycleHook(_a0 *autoscaling.PutLifecycleHookInput) (*autoscaling.PutLifecycleHookOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.PutLifecycleHookOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.PutLifecycleHookInput) *autoscaling.PutLifecycleHookOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.PutLifecycleHookOutput)
		}
	}

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

	return r0, r1
}

// PutLifecycleHookRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutLifecycleHookRequest(_a0 *autoscaling.PutLifecycleHookInput) (*request.Request, *autoscaling.PutLifecycleHookOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.PutLifecycleHookOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.PutLifecycleHookInput) *autoscaling.PutLifecycleHookOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.PutLifecycleHookOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// PutNotificationConfiguration provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutNotificationConfiguration(_a0 *autoscaling.PutNotificationConfigurationInput) (*autoscaling.PutNotificationConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.PutNotificationConfigurationOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.PutNotificationConfigurationInput) *autoscaling.PutNotificationConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.PutNotificationConfigurationOutput)
		}
	}

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

	return r0, r1
}

// PutNotificationConfigurationRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutNotificationConfigurationRequest(_a0 *autoscaling.PutNotificationConfigurationInput) (*request.Request, *autoscaling.PutNotificationConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.PutNotificationConfigurationOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.PutNotificationConfigurationInput) *autoscaling.PutNotificationConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.PutNotificationConfigurationOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// PutScalingPolicy provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutScalingPolicy(_a0 *autoscaling.PutScalingPolicyInput) (*autoscaling.PutScalingPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.PutScalingPolicyOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.PutScalingPolicyInput) *autoscaling.PutScalingPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.PutScalingPolicyOutput)
		}
	}

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

	return r0, r1
}

// PutScalingPolicyRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutScalingPolicyRequest(_a0 *autoscaling.PutScalingPolicyInput) (*request.Request, *autoscaling.PutScalingPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.PutScalingPolicyOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.PutScalingPolicyInput) *autoscaling.PutScalingPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.PutScalingPolicyOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// PutScheduledUpdateGroupAction provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutScheduledUpdateGroupAction(_a0 *autoscaling.PutScheduledUpdateGroupActionInput) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.PutScheduledUpdateGroupActionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.PutScheduledUpdateGroupActionInput) *autoscaling.PutScheduledUpdateGroupActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.PutScheduledUpdateGroupActionOutput)
		}
	}

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

	return r0, r1
}

// PutScheduledUpdateGroupActionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutScheduledUpdateGroupActionRequest(_a0 *autoscaling.PutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.PutScheduledUpdateGroupActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.PutScheduledUpdateGroupActionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.PutScheduledUpdateGroupActionInput) *autoscaling.PutScheduledUpdateGroupActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.PutScheduledUpdateGroupActionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// PutWarmPool provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutWarmPool(_a0 *autoscaling.PutWarmPoolInput) (*autoscaling.PutWarmPoolOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.PutWarmPoolOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.PutWarmPoolInput) *autoscaling.PutWarmPoolOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.PutWarmPoolOutput)
		}
	}

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

	return r0, r1
}

// PutWarmPoolRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) PutWarmPoolRequest(_a0 *autoscaling.PutWarmPoolInput) (*request.Request, *autoscaling.PutWarmPoolOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.PutWarmPoolOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.PutWarmPoolInput) *autoscaling.PutWarmPoolOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.PutWarmPoolOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// RecordLifecycleActionHeartbeat provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) RecordLifecycleActionHeartbeat(_a0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.RecordLifecycleActionHeartbeatOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.RecordLifecycleActionHeartbeatInput) *autoscaling.RecordLifecycleActionHeartbeatOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.RecordLifecycleActionHeartbeatOutput)
		}
	}

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

	return r0, r1
}

// RecordLifecycleActionHeartbeatRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) RecordLifecycleActionHeartbeatRequest(_a0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*request.Request, *autoscaling.RecordLifecycleActionHeartbeatOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.RecordLifecycleActionHeartbeatOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.RecordLifecycleActionHeartbeatInput) *autoscaling.RecordLifecycleActionHeartbeatOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.RecordLifecycleActionHeartbeatOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// ResumeProcesses provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ResumeProcesses(_a0 *autoscaling.ScalingProcessQuery) (*autoscaling.ResumeProcessesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.ResumeProcessesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.ScalingProcessQuery) *autoscaling.ResumeProcessesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.ResumeProcessesOutput)
		}
	}

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

	return r0, r1
}

// ResumeProcessesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) ResumeProcessesRequest(_a0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.ResumeProcessesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.ResumeProcessesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.ScalingProcessQuery) *autoscaling.ResumeProcessesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.ResumeProcessesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// SetDesiredCapacity provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetDesiredCapacity(_a0 *autoscaling.SetDesiredCapacityInput) (*autoscaling.SetDesiredCapacityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.SetDesiredCapacityOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.SetDesiredCapacityInput) *autoscaling.SetDesiredCapacityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.SetDesiredCapacityOutput)
		}
	}

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

	return r0, r1
}

// SetDesiredCapacityRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetDesiredCapacityRequest(_a0 *autoscaling.SetDesiredCapacityInput) (*request.Request, *autoscaling.SetDesiredCapacityOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.SetDesiredCapacityOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.SetDesiredCapacityInput) *autoscaling.SetDesiredCapacityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.SetDesiredCapacityOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// SetInstanceHealth provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetInstanceHealth(_a0 *autoscaling.SetInstanceHealthInput) (*autoscaling.SetInstanceHealthOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.SetInstanceHealthOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.SetInstanceHealthInput) *autoscaling.SetInstanceHealthOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.SetInstanceHealthOutput)
		}
	}

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

	return r0, r1
}

// SetInstanceHealthRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetInstanceHealthRequest(_a0 *autoscaling.SetInstanceHealthInput) (*request.Request, *autoscaling.SetInstanceHealthOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.SetInstanceHealthOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.SetInstanceHealthInput) *autoscaling.SetInstanceHealthOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.SetInstanceHealthOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// SetInstanceProtection provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetInstanceProtection(_a0 *autoscaling.SetInstanceProtectionInput) (*autoscaling.SetInstanceProtectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.SetInstanceProtectionOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.SetInstanceProtectionInput) *autoscaling.SetInstanceProtectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.SetInstanceProtectionOutput)
		}
	}

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

	return r0, r1
}

// SetInstanceProtectionRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SetInstanceProtectionRequest(_a0 *autoscaling.SetInstanceProtectionInput) (*request.Request, *autoscaling.SetInstanceProtectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.SetInstanceProtectionOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.SetInstanceProtectionInput) *autoscaling.SetInstanceProtectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.SetInstanceProtectionOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// StartInstanceRefresh provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) StartInstanceRefresh(_a0 *autoscaling.StartInstanceRefreshInput) (*autoscaling.StartInstanceRefreshOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.StartInstanceRefreshOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.StartInstanceRefreshInput) *autoscaling.StartInstanceRefreshOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.StartInstanceRefreshOutput)
		}
	}

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

	return r0, r1
}

// StartInstanceRefreshRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) StartInstanceRefreshRequest(_a0 *autoscaling.StartInstanceRefreshInput) (*request.Request, *autoscaling.StartInstanceRefreshOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.StartInstanceRefreshOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.StartInstanceRefreshInput) *autoscaling.StartInstanceRefreshOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.StartInstanceRefreshOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// SuspendProcesses provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SuspendProcesses(_a0 *autoscaling.ScalingProcessQuery) (*autoscaling.SuspendProcessesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.SuspendProcessesOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.ScalingProcessQuery) *autoscaling.SuspendProcessesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.SuspendProcessesOutput)
		}
	}

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

	return r0, r1
}

// SuspendProcessesRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) SuspendProcessesRequest(_a0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.SuspendProcessesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.SuspendProcessesOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.ScalingProcessQuery) *autoscaling.SuspendProcessesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.SuspendProcessesOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// TerminateInstanceInAutoScalingGroup provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) TerminateInstanceInAutoScalingGroup(_a0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.TerminateInstanceInAutoScalingGroupOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.TerminateInstanceInAutoScalingGroupInput) *autoscaling.TerminateInstanceInAutoScalingGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.TerminateInstanceInAutoScalingGroupOutput)
		}
	}

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

	return r0, r1
}

// TerminateInstanceInAutoScalingGroupRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) TerminateInstanceInAutoScalingGroupRequest(_a0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*request.Request, *autoscaling.TerminateInstanceInAutoScalingGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.TerminateInstanceInAutoScalingGroupOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.TerminateInstanceInAutoScalingGroupInput) *autoscaling.TerminateInstanceInAutoScalingGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.TerminateInstanceInAutoScalingGroupOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// UpdateAutoScalingGroup provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) UpdateAutoScalingGroup(_a0 *autoscaling.UpdateAutoScalingGroupInput) (*autoscaling.UpdateAutoScalingGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *autoscaling.UpdateAutoScalingGroupOutput
	if rf, ok := ret.Get(0).(func(*autoscaling.UpdateAutoScalingGroupInput) *autoscaling.UpdateAutoScalingGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*autoscaling.UpdateAutoScalingGroupOutput)
		}
	}

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

	return r0, r1
}

// UpdateAutoScalingGroupRequest provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) UpdateAutoScalingGroupRequest(_a0 *autoscaling.UpdateAutoScalingGroupInput) (*request.Request, *autoscaling.UpdateAutoScalingGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *autoscaling.UpdateAutoScalingGroupOutput
	if rf, ok := ret.Get(1).(func(*autoscaling.UpdateAutoScalingGroupInput) *autoscaling.UpdateAutoScalingGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*autoscaling.UpdateAutoScalingGroupOutput)
		}
	}

	return r0, r1
}

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

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

	return r0, r1
}

// WaitUntilGroupExists provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) WaitUntilGroupExists(_a0 *autoscaling.DescribeAutoScalingGroupsInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilGroupInService provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) WaitUntilGroupInService(_a0 *autoscaling.DescribeAutoScalingGroupsInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilGroupNotExists provides a mock function with given fields: _a0
func (_m *AutoScalingAPI) WaitUntilGroupNotExists(_a0 *autoscaling.DescribeAutoScalingGroupsInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}
