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

package mocks

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

	context "context"

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

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

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

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

// ImportStacksToStackSet provides a mock function with given fields: _a0
func (_m *CloudFormationAPI) ImportStacksToStackSet(_a0 *cloudformation.ImportStacksToStackSetInput) (*cloudformation.ImportStacksToStackSetOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// ImportStacksToStackSetRequest provides a mock function with given fields: _a0
func (_m *CloudFormationAPI) ImportStacksToStackSetRequest(_a0 *cloudformation.ImportStacksToStackSetInput) (*request.Request, *cloudformation.ImportStacksToStackSetOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// ImportStacksToStackSetWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *CloudFormationAPI) ImportStacksToStackSetWithContext(_a0 context.Context, _a1 *cloudformation.ImportStacksToStackSetInput, _a2 ...request.Option) (*cloudformation.ImportStacksToStackSetOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.ImportStacksToStackSetOutput
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...request.Option) *cloudformation.ImportStacksToStackSetOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ImportStacksToStackSetOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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
}

// RollbackStack provides a mock function with given fields: _a0
func (_m *CloudFormationAPI) RollbackStack(_a0 *cloudformation.RollbackStackInput) (*cloudformation.RollbackStackOutput, error) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// RollbackStackRequest provides a mock function with given fields: _a0
func (_m *CloudFormationAPI) RollbackStackRequest(_a0 *cloudformation.RollbackStackInput) (*request.Request, *cloudformation.RollbackStackOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// RollbackStackWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *CloudFormationAPI) RollbackStackWithContext(_a0 context.Context, _a1 *cloudformation.RollbackStackInput, _a2 ...request.Option) (*cloudformation.RollbackStackOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := 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.RollbackStackOutput
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RollbackStackInput, ...request.Option) *cloudformation.RollbackStackOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RollbackStackOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.RollbackStackInput, ...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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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 *CloudFormationAPI) 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
}
