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

package aws

import (
	context "context"

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

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

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

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

// ActivateType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ActivateType(_a0 *cloudformation.ActivateTypeInput) (*cloudformation.ActivateTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ActivateTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ActivateTypeInput) *cloudformation.ActivateTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ActivateTypeOutput)
		}
	}

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

	return r0, r1
}

// ActivateTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ActivateTypeRequest(_a0 *cloudformation.ActivateTypeInput) (*request.Request, *cloudformation.ActivateTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ActivateTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ActivateTypeInput) *cloudformation.ActivateTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ActivateTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// BatchDescribeTypeConfigurations provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) BatchDescribeTypeConfigurations(_a0 *cloudformation.BatchDescribeTypeConfigurationsInput) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.BatchDescribeTypeConfigurationsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.BatchDescribeTypeConfigurationsInput) *cloudformation.BatchDescribeTypeConfigurationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.BatchDescribeTypeConfigurationsOutput)
		}
	}

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

	return r0, r1
}

// BatchDescribeTypeConfigurationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) BatchDescribeTypeConfigurationsRequest(_a0 *cloudformation.BatchDescribeTypeConfigurationsInput) (*request.Request, *cloudformation.BatchDescribeTypeConfigurationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.BatchDescribeTypeConfigurationsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.BatchDescribeTypeConfigurationsInput) *cloudformation.BatchDescribeTypeConfigurationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.BatchDescribeTypeConfigurationsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CancelUpdateStack provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CancelUpdateStack(_a0 *cloudformation.CancelUpdateStackInput) (*cloudformation.CancelUpdateStackOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.CancelUpdateStackOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.CancelUpdateStackInput) *cloudformation.CancelUpdateStackOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CancelUpdateStackOutput)
		}
	}

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

	return r0, r1
}

// CancelUpdateStackRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CancelUpdateStackRequest(_a0 *cloudformation.CancelUpdateStackInput) (*request.Request, *cloudformation.CancelUpdateStackOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.CancelUpdateStackOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.CancelUpdateStackInput) *cloudformation.CancelUpdateStackOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.CancelUpdateStackOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ContinueUpdateRollback provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ContinueUpdateRollback(_a0 *cloudformation.ContinueUpdateRollbackInput) (*cloudformation.ContinueUpdateRollbackOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ContinueUpdateRollbackOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ContinueUpdateRollbackInput) *cloudformation.ContinueUpdateRollbackOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ContinueUpdateRollbackOutput)
		}
	}

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

	return r0, r1
}

// ContinueUpdateRollbackRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ContinueUpdateRollbackRequest(_a0 *cloudformation.ContinueUpdateRollbackInput) (*request.Request, *cloudformation.ContinueUpdateRollbackOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ContinueUpdateRollbackOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ContinueUpdateRollbackInput) *cloudformation.ContinueUpdateRollbackOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ContinueUpdateRollbackOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateChangeSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateChangeSet(_a0 *cloudformation.CreateChangeSetInput) (*cloudformation.CreateChangeSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.CreateChangeSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.CreateChangeSetInput) *cloudformation.CreateChangeSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateChangeSetOutput)
		}
	}

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

	return r0, r1
}

// CreateChangeSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateChangeSetRequest(_a0 *cloudformation.CreateChangeSetInput) (*request.Request, *cloudformation.CreateChangeSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.CreateChangeSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.CreateChangeSetInput) *cloudformation.CreateChangeSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.CreateChangeSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateStack provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStack(_a0 *cloudformation.CreateStackInput) (*cloudformation.CreateStackOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.CreateStackOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.CreateStackInput) *cloudformation.CreateStackOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackOutput)
		}
	}

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

	return r0, r1
}

// CreateStackInstances provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStackInstances(_a0 *cloudformation.CreateStackInstancesInput) (*cloudformation.CreateStackInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.CreateStackInstancesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.CreateStackInstancesInput) *cloudformation.CreateStackInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackInstancesOutput)
		}
	}

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

	return r0, r1
}

// CreateStackInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStackInstancesRequest(_a0 *cloudformation.CreateStackInstancesInput) (*request.Request, *cloudformation.CreateStackInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.CreateStackInstancesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.CreateStackInstancesInput) *cloudformation.CreateStackInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.CreateStackInstancesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// CreateStackRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStackRequest(_a0 *cloudformation.CreateStackInput) (*request.Request, *cloudformation.CreateStackOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.CreateStackOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.CreateStackInput) *cloudformation.CreateStackOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.CreateStackOutput)
		}
	}

	return r0, r1
}

// CreateStackSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStackSet(_a0 *cloudformation.CreateStackSetInput) (*cloudformation.CreateStackSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.CreateStackSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.CreateStackSetInput) *cloudformation.CreateStackSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackSetOutput)
		}
	}

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

	return r0, r1
}

// CreateStackSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) CreateStackSetRequest(_a0 *cloudformation.CreateStackSetInput) (*request.Request, *cloudformation.CreateStackSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.CreateStackSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.CreateStackSetInput) *cloudformation.CreateStackSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.CreateStackSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeactivateType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeactivateType(_a0 *cloudformation.DeactivateTypeInput) (*cloudformation.DeactivateTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeactivateTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeactivateTypeInput) *cloudformation.DeactivateTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeactivateTypeOutput)
		}
	}

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

	return r0, r1
}

// DeactivateTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeactivateTypeRequest(_a0 *cloudformation.DeactivateTypeInput) (*request.Request, *cloudformation.DeactivateTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeactivateTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeactivateTypeInput) *cloudformation.DeactivateTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeactivateTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteChangeSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteChangeSet(_a0 *cloudformation.DeleteChangeSetInput) (*cloudformation.DeleteChangeSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeleteChangeSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeleteChangeSetInput) *cloudformation.DeleteChangeSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteChangeSetOutput)
		}
	}

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

	return r0, r1
}

// DeleteChangeSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteChangeSetRequest(_a0 *cloudformation.DeleteChangeSetInput) (*request.Request, *cloudformation.DeleteChangeSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeleteChangeSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeleteChangeSetInput) *cloudformation.DeleteChangeSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeleteChangeSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteStack provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStack(_a0 *cloudformation.DeleteStackInput) (*cloudformation.DeleteStackOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeleteStackOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeleteStackInput) *cloudformation.DeleteStackOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackOutput)
		}
	}

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

	return r0, r1
}

// DeleteStackInstances provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStackInstances(_a0 *cloudformation.DeleteStackInstancesInput) (*cloudformation.DeleteStackInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeleteStackInstancesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeleteStackInstancesInput) *cloudformation.DeleteStackInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackInstancesOutput)
		}
	}

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

	return r0, r1
}

// DeleteStackInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStackInstancesRequest(_a0 *cloudformation.DeleteStackInstancesInput) (*request.Request, *cloudformation.DeleteStackInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeleteStackInstancesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeleteStackInstancesInput) *cloudformation.DeleteStackInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeleteStackInstancesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeleteStackRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStackRequest(_a0 *cloudformation.DeleteStackInput) (*request.Request, *cloudformation.DeleteStackOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeleteStackOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeleteStackInput) *cloudformation.DeleteStackOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeleteStackOutput)
		}
	}

	return r0, r1
}

// DeleteStackSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStackSet(_a0 *cloudformation.DeleteStackSetInput) (*cloudformation.DeleteStackSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeleteStackSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeleteStackSetInput) *cloudformation.DeleteStackSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackSetOutput)
		}
	}

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

	return r0, r1
}

// DeleteStackSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeleteStackSetRequest(_a0 *cloudformation.DeleteStackSetInput) (*request.Request, *cloudformation.DeleteStackSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeleteStackSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeleteStackSetInput) *cloudformation.DeleteStackSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeleteStackSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// DeregisterType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeregisterType(_a0 *cloudformation.DeregisterTypeInput) (*cloudformation.DeregisterTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DeregisterTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DeregisterTypeInput) *cloudformation.DeregisterTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeregisterTypeOutput)
		}
	}

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

	return r0, r1
}

// DeregisterTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DeregisterTypeRequest(_a0 *cloudformation.DeregisterTypeInput) (*request.Request, *cloudformation.DeregisterTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DeregisterTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DeregisterTypeInput) *cloudformation.DeregisterTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DeregisterTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

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

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

	return r0, r1
}

// DescribeAccountLimitsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) DescribeAccountLimitsPages(_a0 *cloudformation.DescribeAccountLimitsInput, _a1 func(*cloudformation.DescribeAccountLimitsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

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

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

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

	return r0, r1
}

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

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

	return r0, r1
}

// DescribeChangeSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeChangeSet(_a0 *cloudformation.DescribeChangeSetInput) (*cloudformation.DescribeChangeSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeChangeSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeChangeSetInput) *cloudformation.DescribeChangeSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeChangeSetOutput)
		}
	}

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

	return r0, r1
}

// DescribeChangeSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeChangeSetRequest(_a0 *cloudformation.DescribeChangeSetInput) (*request.Request, *cloudformation.DescribeChangeSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeChangeSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeChangeSetInput) *cloudformation.DescribeChangeSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeChangeSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribePublisher provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribePublisher(_a0 *cloudformation.DescribePublisherInput) (*cloudformation.DescribePublisherOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribePublisherOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribePublisherInput) *cloudformation.DescribePublisherOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribePublisherOutput)
		}
	}

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

	return r0, r1
}

// DescribePublisherRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribePublisherRequest(_a0 *cloudformation.DescribePublisherInput) (*request.Request, *cloudformation.DescribePublisherOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribePublisherOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribePublisherInput) *cloudformation.DescribePublisherOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribePublisherOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackDriftDetectionStatus provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackDriftDetectionStatus(_a0 *cloudformation.DescribeStackDriftDetectionStatusInput) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackDriftDetectionStatusOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackDriftDetectionStatusInput) *cloudformation.DescribeStackDriftDetectionStatusOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackDriftDetectionStatusOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackDriftDetectionStatusRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackDriftDetectionStatusRequest(_a0 *cloudformation.DescribeStackDriftDetectionStatusInput) (*request.Request, *cloudformation.DescribeStackDriftDetectionStatusOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackDriftDetectionStatusOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackDriftDetectionStatusInput) *cloudformation.DescribeStackDriftDetectionStatusOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackDriftDetectionStatusOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackEvents provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackEvents(_a0 *cloudformation.DescribeStackEventsInput) (*cloudformation.DescribeStackEventsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackEventsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackEventsInput) *cloudformation.DescribeStackEventsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackEventsOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackEventsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) DescribeStackEventsPages(_a0 *cloudformation.DescribeStackEventsInput, _a1 func(*cloudformation.DescribeStackEventsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeStackEventsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackEventsRequest(_a0 *cloudformation.DescribeStackEventsInput) (*request.Request, *cloudformation.DescribeStackEventsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackEventsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackEventsInput) *cloudformation.DescribeStackEventsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackEventsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackInstance provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackInstance(_a0 *cloudformation.DescribeStackInstanceInput) (*cloudformation.DescribeStackInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackInstanceOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackInstanceInput) *cloudformation.DescribeStackInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackInstanceOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackInstanceRequest(_a0 *cloudformation.DescribeStackInstanceInput) (*request.Request, *cloudformation.DescribeStackInstanceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackInstanceOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackInstanceInput) *cloudformation.DescribeStackInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackInstanceOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackResource provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResource(_a0 *cloudformation.DescribeStackResourceInput) (*cloudformation.DescribeStackResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackResourceOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackResourceInput) *cloudformation.DescribeStackResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourceOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackResourceDrifts provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResourceDrifts(_a0 *cloudformation.DescribeStackResourceDriftsInput) (*cloudformation.DescribeStackResourceDriftsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackResourceDriftsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackResourceDriftsInput) *cloudformation.DescribeStackResourceDriftsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourceDriftsOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackResourceDriftsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) DescribeStackResourceDriftsPages(_a0 *cloudformation.DescribeStackResourceDriftsInput, _a1 func(*cloudformation.DescribeStackResourceDriftsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeStackResourceDriftsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResourceDriftsRequest(_a0 *cloudformation.DescribeStackResourceDriftsInput) (*request.Request, *cloudformation.DescribeStackResourceDriftsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackResourceDriftsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackResourceDriftsInput) *cloudformation.DescribeStackResourceDriftsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackResourceDriftsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResourceRequest(_a0 *cloudformation.DescribeStackResourceInput) (*request.Request, *cloudformation.DescribeStackResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackResourceOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackResourceInput) *cloudformation.DescribeStackResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackResourceOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackResources provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResources(_a0 *cloudformation.DescribeStackResourcesInput) (*cloudformation.DescribeStackResourcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackResourcesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackResourcesInput) *cloudformation.DescribeStackResourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourcesOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackResourcesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackResourcesRequest(_a0 *cloudformation.DescribeStackResourcesInput) (*request.Request, *cloudformation.DescribeStackResourcesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackResourcesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackResourcesInput) *cloudformation.DescribeStackResourcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackResourcesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackSet(_a0 *cloudformation.DescribeStackSetInput) (*cloudformation.DescribeStackSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackSetInput) *cloudformation.DescribeStackSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackSetOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackSetOperation provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackSetOperation(_a0 *cloudformation.DescribeStackSetOperationInput) (*cloudformation.DescribeStackSetOperationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStackSetOperationOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStackSetOperationInput) *cloudformation.DescribeStackSetOperationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackSetOperationOutput)
		}
	}

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

	return r0, r1
}

// DescribeStackSetOperationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackSetOperationRequest(_a0 *cloudformation.DescribeStackSetOperationInput) (*request.Request, *cloudformation.DescribeStackSetOperationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackSetOperationOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackSetOperationInput) *cloudformation.DescribeStackSetOperationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackSetOperationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStackSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStackSetRequest(_a0 *cloudformation.DescribeStackSetInput) (*request.Request, *cloudformation.DescribeStackSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStackSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStackSetInput) *cloudformation.DescribeStackSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStackSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeStacks provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStacks(_a0 *cloudformation.DescribeStacksInput) (*cloudformation.DescribeStacksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeStacksOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeStacksInput) *cloudformation.DescribeStacksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStacksOutput)
		}
	}

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

	return r0, r1
}

// DescribeStacksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) DescribeStacksPages(_a0 *cloudformation.DescribeStacksInput, _a1 func(*cloudformation.DescribeStacksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// DescribeStacksRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeStacksRequest(_a0 *cloudformation.DescribeStacksInput) (*request.Request, *cloudformation.DescribeStacksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeStacksOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeStacksInput) *cloudformation.DescribeStacksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeStacksOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeType(_a0 *cloudformation.DescribeTypeInput) (*cloudformation.DescribeTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeTypeInput) *cloudformation.DescribeTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeTypeOutput)
		}
	}

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

	return r0, r1
}

// DescribeTypeRegistration provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeTypeRegistration(_a0 *cloudformation.DescribeTypeRegistrationInput) (*cloudformation.DescribeTypeRegistrationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DescribeTypeRegistrationOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DescribeTypeRegistrationInput) *cloudformation.DescribeTypeRegistrationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeTypeRegistrationOutput)
		}
	}

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

	return r0, r1
}

// DescribeTypeRegistrationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeTypeRegistrationRequest(_a0 *cloudformation.DescribeTypeRegistrationInput) (*request.Request, *cloudformation.DescribeTypeRegistrationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeTypeRegistrationOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeTypeRegistrationInput) *cloudformation.DescribeTypeRegistrationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeTypeRegistrationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DescribeTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DescribeTypeRequest(_a0 *cloudformation.DescribeTypeInput) (*request.Request, *cloudformation.DescribeTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DescribeTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DescribeTypeInput) *cloudformation.DescribeTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DescribeTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DetectStackDrift provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackDrift(_a0 *cloudformation.DetectStackDriftInput) (*cloudformation.DetectStackDriftOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DetectStackDriftOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DetectStackDriftInput) *cloudformation.DetectStackDriftOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackDriftOutput)
		}
	}

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

	return r0, r1
}

// DetectStackDriftRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackDriftRequest(_a0 *cloudformation.DetectStackDriftInput) (*request.Request, *cloudformation.DetectStackDriftOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DetectStackDriftOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DetectStackDriftInput) *cloudformation.DetectStackDriftOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DetectStackDriftOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DetectStackResourceDrift provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackResourceDrift(_a0 *cloudformation.DetectStackResourceDriftInput) (*cloudformation.DetectStackResourceDriftOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DetectStackResourceDriftOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DetectStackResourceDriftInput) *cloudformation.DetectStackResourceDriftOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackResourceDriftOutput)
		}
	}

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

	return r0, r1
}

// DetectStackResourceDriftRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackResourceDriftRequest(_a0 *cloudformation.DetectStackResourceDriftInput) (*request.Request, *cloudformation.DetectStackResourceDriftOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DetectStackResourceDriftOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DetectStackResourceDriftInput) *cloudformation.DetectStackResourceDriftOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DetectStackResourceDriftOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// DetectStackSetDrift provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackSetDrift(_a0 *cloudformation.DetectStackSetDriftInput) (*cloudformation.DetectStackSetDriftOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.DetectStackSetDriftOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.DetectStackSetDriftInput) *cloudformation.DetectStackSetDriftOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackSetDriftOutput)
		}
	}

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

	return r0, r1
}

// DetectStackSetDriftRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) DetectStackSetDriftRequest(_a0 *cloudformation.DetectStackSetDriftInput) (*request.Request, *cloudformation.DetectStackSetDriftOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.DetectStackSetDriftOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.DetectStackSetDriftInput) *cloudformation.DetectStackSetDriftOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.DetectStackSetDriftOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// EstimateTemplateCost provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) EstimateTemplateCost(_a0 *cloudformation.EstimateTemplateCostInput) (*cloudformation.EstimateTemplateCostOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.EstimateTemplateCostOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.EstimateTemplateCostInput) *cloudformation.EstimateTemplateCostOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.EstimateTemplateCostOutput)
		}
	}

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

	return r0, r1
}

// EstimateTemplateCostRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) EstimateTemplateCostRequest(_a0 *cloudformation.EstimateTemplateCostInput) (*request.Request, *cloudformation.EstimateTemplateCostOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.EstimateTemplateCostOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.EstimateTemplateCostInput) *cloudformation.EstimateTemplateCostOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.EstimateTemplateCostOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ExecuteChangeSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ExecuteChangeSet(_a0 *cloudformation.ExecuteChangeSetInput) (*cloudformation.ExecuteChangeSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ExecuteChangeSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ExecuteChangeSetInput) *cloudformation.ExecuteChangeSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ExecuteChangeSetOutput)
		}
	}

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

	return r0, r1
}

// ExecuteChangeSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ExecuteChangeSetRequest(_a0 *cloudformation.ExecuteChangeSetInput) (*request.Request, *cloudformation.ExecuteChangeSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ExecuteChangeSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ExecuteChangeSetInput) *cloudformation.ExecuteChangeSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ExecuteChangeSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetStackPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetStackPolicy(_a0 *cloudformation.GetStackPolicyInput) (*cloudformation.GetStackPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.GetStackPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.GetStackPolicyInput) *cloudformation.GetStackPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetStackPolicyOutput)
		}
	}

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

	return r0, r1
}

// GetStackPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetStackPolicyRequest(_a0 *cloudformation.GetStackPolicyInput) (*request.Request, *cloudformation.GetStackPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.GetStackPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.GetStackPolicyInput) *cloudformation.GetStackPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.GetStackPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// GetTemplate provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetTemplate(_a0 *cloudformation.GetTemplateInput) (*cloudformation.GetTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.GetTemplateOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.GetTemplateInput) *cloudformation.GetTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetTemplateOutput)
		}
	}

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

	return r0, r1
}

// GetTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetTemplateRequest(_a0 *cloudformation.GetTemplateInput) (*request.Request, *cloudformation.GetTemplateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.GetTemplateOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.GetTemplateInput) *cloudformation.GetTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.GetTemplateOutput)
		}
	}

	return r0, r1
}

// GetTemplateSummary provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetTemplateSummary(_a0 *cloudformation.GetTemplateSummaryInput) (*cloudformation.GetTemplateSummaryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.GetTemplateSummaryOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.GetTemplateSummaryInput) *cloudformation.GetTemplateSummaryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetTemplateSummaryOutput)
		}
	}

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

	return r0, r1
}

// GetTemplateSummaryRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) GetTemplateSummaryRequest(_a0 *cloudformation.GetTemplateSummaryInput) (*request.Request, *cloudformation.GetTemplateSummaryOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.GetTemplateSummaryOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.GetTemplateSummaryInput) *cloudformation.GetTemplateSummaryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.GetTemplateSummaryOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListChangeSets provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListChangeSets(_a0 *cloudformation.ListChangeSetsInput) (*cloudformation.ListChangeSetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListChangeSetsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListChangeSetsInput) *cloudformation.ListChangeSetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListChangeSetsOutput)
		}
	}

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

	return r0, r1
}

// ListChangeSetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListChangeSetsPages(_a0 *cloudformation.ListChangeSetsInput, _a1 func(*cloudformation.ListChangeSetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListChangeSetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListChangeSetsRequest(_a0 *cloudformation.ListChangeSetsInput) (*request.Request, *cloudformation.ListChangeSetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListChangeSetsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListChangeSetsInput) *cloudformation.ListChangeSetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListChangeSetsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListExports provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListExports(_a0 *cloudformation.ListExportsInput) (*cloudformation.ListExportsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListExportsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListExportsInput) *cloudformation.ListExportsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListExportsOutput)
		}
	}

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

	return r0, r1
}

// ListExportsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListExportsPages(_a0 *cloudformation.ListExportsInput, _a1 func(*cloudformation.ListExportsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListExportsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListExportsRequest(_a0 *cloudformation.ListExportsInput) (*request.Request, *cloudformation.ListExportsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListExportsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListExportsInput) *cloudformation.ListExportsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListExportsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListImports provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListImports(_a0 *cloudformation.ListImportsInput) (*cloudformation.ListImportsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListImportsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListImportsInput) *cloudformation.ListImportsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListImportsOutput)
		}
	}

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

	return r0, r1
}

// ListImportsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListImportsPages(_a0 *cloudformation.ListImportsInput, _a1 func(*cloudformation.ListImportsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListImportsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListImportsRequest(_a0 *cloudformation.ListImportsInput) (*request.Request, *cloudformation.ListImportsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListImportsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListImportsInput) *cloudformation.ListImportsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListImportsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStackInstances provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackInstances(_a0 *cloudformation.ListStackInstancesInput) (*cloudformation.ListStackInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStackInstancesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStackInstancesInput) *cloudformation.ListStackInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackInstancesOutput)
		}
	}

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

	return r0, r1
}

// ListStackInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStackInstancesPages(_a0 *cloudformation.ListStackInstancesInput, _a1 func(*cloudformation.ListStackInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStackInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackInstancesRequest(_a0 *cloudformation.ListStackInstancesInput) (*request.Request, *cloudformation.ListStackInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStackInstancesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStackInstancesInput) *cloudformation.ListStackInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStackInstancesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStackResources provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackResources(_a0 *cloudformation.ListStackResourcesInput) (*cloudformation.ListStackResourcesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStackResourcesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStackResourcesInput) *cloudformation.ListStackResourcesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackResourcesOutput)
		}
	}

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

	return r0, r1
}

// ListStackResourcesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStackResourcesPages(_a0 *cloudformation.ListStackResourcesInput, _a1 func(*cloudformation.ListStackResourcesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStackResourcesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackResourcesRequest(_a0 *cloudformation.ListStackResourcesInput) (*request.Request, *cloudformation.ListStackResourcesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStackResourcesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStackResourcesInput) *cloudformation.ListStackResourcesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStackResourcesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStackSetOperationResults provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSetOperationResults(_a0 *cloudformation.ListStackSetOperationResultsInput) (*cloudformation.ListStackSetOperationResultsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStackSetOperationResultsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStackSetOperationResultsInput) *cloudformation.ListStackSetOperationResultsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetOperationResultsOutput)
		}
	}

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

	return r0, r1
}

// ListStackSetOperationResultsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStackSetOperationResultsPages(_a0 *cloudformation.ListStackSetOperationResultsInput, _a1 func(*cloudformation.ListStackSetOperationResultsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStackSetOperationResultsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSetOperationResultsRequest(_a0 *cloudformation.ListStackSetOperationResultsInput) (*request.Request, *cloudformation.ListStackSetOperationResultsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStackSetOperationResultsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStackSetOperationResultsInput) *cloudformation.ListStackSetOperationResultsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStackSetOperationResultsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStackSetOperations provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSetOperations(_a0 *cloudformation.ListStackSetOperationsInput) (*cloudformation.ListStackSetOperationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStackSetOperationsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStackSetOperationsInput) *cloudformation.ListStackSetOperationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetOperationsOutput)
		}
	}

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

	return r0, r1
}

// ListStackSetOperationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStackSetOperationsPages(_a0 *cloudformation.ListStackSetOperationsInput, _a1 func(*cloudformation.ListStackSetOperationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStackSetOperationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSetOperationsRequest(_a0 *cloudformation.ListStackSetOperationsInput) (*request.Request, *cloudformation.ListStackSetOperationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStackSetOperationsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStackSetOperationsInput) *cloudformation.ListStackSetOperationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStackSetOperationsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStackSets provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSets(_a0 *cloudformation.ListStackSetsInput) (*cloudformation.ListStackSetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStackSetsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStackSetsInput) *cloudformation.ListStackSetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetsOutput)
		}
	}

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

	return r0, r1
}

// ListStackSetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStackSetsPages(_a0 *cloudformation.ListStackSetsInput, _a1 func(*cloudformation.ListStackSetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStackSetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStackSetsRequest(_a0 *cloudformation.ListStackSetsInput) (*request.Request, *cloudformation.ListStackSetsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStackSetsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStackSetsInput) *cloudformation.ListStackSetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStackSetsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListStacks provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStacks(_a0 *cloudformation.ListStacksInput) (*cloudformation.ListStacksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListStacksOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListStacksInput) *cloudformation.ListStacksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStacksOutput)
		}
	}

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

	return r0, r1
}

// ListStacksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListStacksPages(_a0 *cloudformation.ListStacksInput, _a1 func(*cloudformation.ListStacksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListStacksRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListStacksRequest(_a0 *cloudformation.ListStacksInput) (*request.Request, *cloudformation.ListStacksOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListStacksOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListStacksInput) *cloudformation.ListStacksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListStacksOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListTypeRegistrations provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypeRegistrations(_a0 *cloudformation.ListTypeRegistrationsInput) (*cloudformation.ListTypeRegistrationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListTypeRegistrationsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListTypeRegistrationsInput) *cloudformation.ListTypeRegistrationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypeRegistrationsOutput)
		}
	}

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

	return r0, r1
}

// ListTypeRegistrationsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListTypeRegistrationsPages(_a0 *cloudformation.ListTypeRegistrationsInput, _a1 func(*cloudformation.ListTypeRegistrationsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListTypeRegistrationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypeRegistrationsRequest(_a0 *cloudformation.ListTypeRegistrationsInput) (*request.Request, *cloudformation.ListTypeRegistrationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListTypeRegistrationsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListTypeRegistrationsInput) *cloudformation.ListTypeRegistrationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListTypeRegistrationsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListTypeVersions provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypeVersions(_a0 *cloudformation.ListTypeVersionsInput) (*cloudformation.ListTypeVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListTypeVersionsOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListTypeVersionsInput) *cloudformation.ListTypeVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypeVersionsOutput)
		}
	}

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

	return r0, r1
}

// ListTypeVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListTypeVersionsPages(_a0 *cloudformation.ListTypeVersionsInput, _a1 func(*cloudformation.ListTypeVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListTypeVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypeVersionsRequest(_a0 *cloudformation.ListTypeVersionsInput) (*request.Request, *cloudformation.ListTypeVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListTypeVersionsOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListTypeVersionsInput) *cloudformation.ListTypeVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListTypeVersionsOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListTypes provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypes(_a0 *cloudformation.ListTypesInput) (*cloudformation.ListTypesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ListTypesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ListTypesInput) *cloudformation.ListTypesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypesOutput)
		}
	}

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

	return r0, r1
}

// ListTypesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeCloudformation) ListTypesPages(_a0 *cloudformation.ListTypesInput, _a1 func(*cloudformation.ListTypesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

	return r0
}

// ListTypesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ListTypesRequest(_a0 *cloudformation.ListTypesInput) (*request.Request, *cloudformation.ListTypesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ListTypesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ListTypesInput) *cloudformation.ListTypesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ListTypesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// PublishType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) PublishType(_a0 *cloudformation.PublishTypeInput) (*cloudformation.PublishTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.PublishTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.PublishTypeInput) *cloudformation.PublishTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.PublishTypeOutput)
		}
	}

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

	return r0, r1
}

// PublishTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) PublishTypeRequest(_a0 *cloudformation.PublishTypeInput) (*request.Request, *cloudformation.PublishTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.PublishTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.PublishTypeInput) *cloudformation.PublishTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.PublishTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// RecordHandlerProgress provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RecordHandlerProgress(_a0 *cloudformation.RecordHandlerProgressInput) (*cloudformation.RecordHandlerProgressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.RecordHandlerProgressOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.RecordHandlerProgressInput) *cloudformation.RecordHandlerProgressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RecordHandlerProgressOutput)
		}
	}

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

	return r0, r1
}

// RecordHandlerProgressRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RecordHandlerProgressRequest(_a0 *cloudformation.RecordHandlerProgressInput) (*request.Request, *cloudformation.RecordHandlerProgressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.RecordHandlerProgressOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.RecordHandlerProgressInput) *cloudformation.RecordHandlerProgressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.RecordHandlerProgressOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterPublisher provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RegisterPublisher(_a0 *cloudformation.RegisterPublisherInput) (*cloudformation.RegisterPublisherOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.RegisterPublisherOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.RegisterPublisherInput) *cloudformation.RegisterPublisherOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RegisterPublisherOutput)
		}
	}

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

	return r0, r1
}

// RegisterPublisherRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RegisterPublisherRequest(_a0 *cloudformation.RegisterPublisherInput) (*request.Request, *cloudformation.RegisterPublisherOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.RegisterPublisherOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.RegisterPublisherInput) *cloudformation.RegisterPublisherOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.RegisterPublisherOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// RegisterType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RegisterType(_a0 *cloudformation.RegisterTypeInput) (*cloudformation.RegisterTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.RegisterTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.RegisterTypeInput) *cloudformation.RegisterTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RegisterTypeOutput)
		}
	}

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

	return r0, r1
}

// RegisterTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) RegisterTypeRequest(_a0 *cloudformation.RegisterTypeInput) (*request.Request, *cloudformation.RegisterTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.RegisterTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.RegisterTypeInput) *cloudformation.RegisterTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.RegisterTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// SetStackPolicy provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetStackPolicy(_a0 *cloudformation.SetStackPolicyInput) (*cloudformation.SetStackPolicyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.SetStackPolicyOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.SetStackPolicyInput) *cloudformation.SetStackPolicyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetStackPolicyOutput)
		}
	}

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

	return r0, r1
}

// SetStackPolicyRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetStackPolicyRequest(_a0 *cloudformation.SetStackPolicyInput) (*request.Request, *cloudformation.SetStackPolicyOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.SetStackPolicyOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.SetStackPolicyInput) *cloudformation.SetStackPolicyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.SetStackPolicyOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// SetTypeConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetTypeConfiguration(_a0 *cloudformation.SetTypeConfigurationInput) (*cloudformation.SetTypeConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.SetTypeConfigurationOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.SetTypeConfigurationInput) *cloudformation.SetTypeConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetTypeConfigurationOutput)
		}
	}

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

	return r0, r1
}

// SetTypeConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetTypeConfigurationRequest(_a0 *cloudformation.SetTypeConfigurationInput) (*request.Request, *cloudformation.SetTypeConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.SetTypeConfigurationOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.SetTypeConfigurationInput) *cloudformation.SetTypeConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.SetTypeConfigurationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// SetTypeDefaultVersion provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetTypeDefaultVersion(_a0 *cloudformation.SetTypeDefaultVersionInput) (*cloudformation.SetTypeDefaultVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.SetTypeDefaultVersionOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.SetTypeDefaultVersionInput) *cloudformation.SetTypeDefaultVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetTypeDefaultVersionOutput)
		}
	}

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

	return r0, r1
}

// SetTypeDefaultVersionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SetTypeDefaultVersionRequest(_a0 *cloudformation.SetTypeDefaultVersionInput) (*request.Request, *cloudformation.SetTypeDefaultVersionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.SetTypeDefaultVersionOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.SetTypeDefaultVersionInput) *cloudformation.SetTypeDefaultVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.SetTypeDefaultVersionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// SignalResource provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SignalResource(_a0 *cloudformation.SignalResourceInput) (*cloudformation.SignalResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.SignalResourceOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.SignalResourceInput) *cloudformation.SignalResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SignalResourceOutput)
		}
	}

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

	return r0, r1
}

// SignalResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) SignalResourceRequest(_a0 *cloudformation.SignalResourceInput) (*request.Request, *cloudformation.SignalResourceOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.SignalResourceOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.SignalResourceInput) *cloudformation.SignalResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.SignalResourceOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// StopStackSetOperation provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) StopStackSetOperation(_a0 *cloudformation.StopStackSetOperationInput) (*cloudformation.StopStackSetOperationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.StopStackSetOperationOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.StopStackSetOperationInput) *cloudformation.StopStackSetOperationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.StopStackSetOperationOutput)
		}
	}

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

	return r0, r1
}

// StopStackSetOperationRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) StopStackSetOperationRequest(_a0 *cloudformation.StopStackSetOperationInput) (*request.Request, *cloudformation.StopStackSetOperationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.StopStackSetOperationOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.StopStackSetOperationInput) *cloudformation.StopStackSetOperationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.StopStackSetOperationOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// TestType provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) TestType(_a0 *cloudformation.TestTypeInput) (*cloudformation.TestTypeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.TestTypeOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.TestTypeInput) *cloudformation.TestTypeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.TestTypeOutput)
		}
	}

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

	return r0, r1
}

// TestTypeRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) TestTypeRequest(_a0 *cloudformation.TestTypeInput) (*request.Request, *cloudformation.TestTypeOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.TestTypeOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.TestTypeInput) *cloudformation.TestTypeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.TestTypeOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateStack provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStack(_a0 *cloudformation.UpdateStackInput) (*cloudformation.UpdateStackOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.UpdateStackOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.UpdateStackInput) *cloudformation.UpdateStackOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackOutput)
		}
	}

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

	return r0, r1
}

// UpdateStackInstances provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStackInstances(_a0 *cloudformation.UpdateStackInstancesInput) (*cloudformation.UpdateStackInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.UpdateStackInstancesOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.UpdateStackInstancesInput) *cloudformation.UpdateStackInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackInstancesOutput)
		}
	}

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

	return r0, r1
}

// UpdateStackInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStackInstancesRequest(_a0 *cloudformation.UpdateStackInstancesInput) (*request.Request, *cloudformation.UpdateStackInstancesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.UpdateStackInstancesOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.UpdateStackInstancesInput) *cloudformation.UpdateStackInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.UpdateStackInstancesOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateStackRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStackRequest(_a0 *cloudformation.UpdateStackInput) (*request.Request, *cloudformation.UpdateStackOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.UpdateStackOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.UpdateStackInput) *cloudformation.UpdateStackOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.UpdateStackOutput)
		}
	}

	return r0, r1
}

// UpdateStackSet provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStackSet(_a0 *cloudformation.UpdateStackSetInput) (*cloudformation.UpdateStackSetOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.UpdateStackSetOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.UpdateStackSetInput) *cloudformation.UpdateStackSetOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackSetOutput)
		}
	}

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

	return r0, r1
}

// UpdateStackSetRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateStackSetRequest(_a0 *cloudformation.UpdateStackSetInput) (*request.Request, *cloudformation.UpdateStackSetOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.UpdateStackSetOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.UpdateStackSetInput) *cloudformation.UpdateStackSetOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.UpdateStackSetOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// UpdateTerminationProtection provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateTerminationProtection(_a0 *cloudformation.UpdateTerminationProtectionInput) (*cloudformation.UpdateTerminationProtectionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.UpdateTerminationProtectionOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.UpdateTerminationProtectionInput) *cloudformation.UpdateTerminationProtectionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateTerminationProtectionOutput)
		}
	}

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

	return r0, r1
}

// UpdateTerminationProtectionRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) UpdateTerminationProtectionRequest(_a0 *cloudformation.UpdateTerminationProtectionInput) (*request.Request, *cloudformation.UpdateTerminationProtectionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.UpdateTerminationProtectionOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.UpdateTerminationProtectionInput) *cloudformation.UpdateTerminationProtectionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.UpdateTerminationProtectionOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// ValidateTemplate provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ValidateTemplate(_a0 *cloudformation.ValidateTemplateInput) (*cloudformation.ValidateTemplateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *cloudformation.ValidateTemplateOutput
	if rf, ok := ret.Get(0).(func(*cloudformation.ValidateTemplateInput) *cloudformation.ValidateTemplateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ValidateTemplateOutput)
		}
	}

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

	return r0, r1
}

// ValidateTemplateRequest provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) ValidateTemplateRequest(_a0 *cloudformation.ValidateTemplateInput) (*request.Request, *cloudformation.ValidateTemplateOutput) {
	ret := _m.Called(_a0)

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

	var r1 *cloudformation.ValidateTemplateOutput
	if rf, ok := ret.Get(1).(func(*cloudformation.ValidateTemplateInput) *cloudformation.ValidateTemplateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*cloudformation.ValidateTemplateOutput)
		}
	}

	return r0, r1
}

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

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

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

	return r0, r1
}

// WaitUntilChangeSetCreateComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilChangeSetCreateComplete(_a0 *cloudformation.DescribeChangeSetInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackCreateComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackCreateComplete(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackDeleteComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackDeleteComplete(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackExists provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackExists(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackImportComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackImportComplete(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackRollbackComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackRollbackComplete(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilStackUpdateComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilStackUpdateComplete(_a0 *cloudformation.DescribeStacksInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}

// WaitUntilTypeRegistrationComplete provides a mock function with given fields: _a0
func (_m *MockFakeCloudformation) WaitUntilTypeRegistrationComplete(_a0 *cloudformation.DescribeTypeRegistrationInput) error {
	ret := _m.Called(_a0)

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

	return r0
}

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

	return r0
}