driftctl/test/aws/mock_FakeAutoscaling.go

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

package aws

import (
	context "context"

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

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

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

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

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