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

package mocksv2

import (
	context "context"

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

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

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

type CloudFormation_Expecter struct {
	mock *mock.Mock
}

func (_m *CloudFormation) EXPECT() *CloudFormation_Expecter {
	return &CloudFormation_Expecter{mock: &_m.Mock}
}

// ActivateOrganizationsAccess provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ActivateOrganizationsAccess(ctx context.Context, params *cloudformation.ActivateOrganizationsAccessInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ActivateOrganizationsAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ActivateOrganizationsAccess")
	}

	var r0 *cloudformation.ActivateOrganizationsAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ActivateOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.ActivateOrganizationsAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ActivateOrganizationsAccessInput, ...func(*cloudformation.Options)) *cloudformation.ActivateOrganizationsAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ActivateOrganizationsAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ActivateOrganizationsAccessInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ActivateOrganizationsAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateOrganizationsAccess'
type CloudFormation_ActivateOrganizationsAccess_Call struct {
	*mock.Call
}

// ActivateOrganizationsAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ActivateOrganizationsAccessInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ActivateOrganizationsAccess(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ActivateOrganizationsAccess_Call {
	return &CloudFormation_ActivateOrganizationsAccess_Call{Call: _e.mock.On("ActivateOrganizationsAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ActivateOrganizationsAccess_Call) Run(run func(ctx context.Context, params *cloudformation.ActivateOrganizationsAccessInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ActivateOrganizationsAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ActivateOrganizationsAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ActivateOrganizationsAccess_Call) Return(_a0 *cloudformation.ActivateOrganizationsAccessOutput, _a1 error) *CloudFormation_ActivateOrganizationsAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ActivateOrganizationsAccess_Call) RunAndReturn(run func(context.Context, *cloudformation.ActivateOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.ActivateOrganizationsAccessOutput, error)) *CloudFormation_ActivateOrganizationsAccess_Call {
	_c.Call.Return(run)
	return _c
}

// ActivateType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ActivateType(ctx context.Context, params *cloudformation.ActivateTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ActivateTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ActivateType")
	}

	var r0 *cloudformation.ActivateTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ActivateTypeInput, ...func(*cloudformation.Options)) (*cloudformation.ActivateTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ActivateTypeInput, ...func(*cloudformation.Options)) *cloudformation.ActivateTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ActivateTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ActivateTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ActivateType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateType'
type CloudFormation_ActivateType_Call struct {
	*mock.Call
}

// ActivateType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ActivateTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ActivateType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ActivateType_Call {
	return &CloudFormation_ActivateType_Call{Call: _e.mock.On("ActivateType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ActivateType_Call) Run(run func(ctx context.Context, params *cloudformation.ActivateTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ActivateType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ActivateTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ActivateType_Call) Return(_a0 *cloudformation.ActivateTypeOutput, _a1 error) *CloudFormation_ActivateType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ActivateType_Call) RunAndReturn(run func(context.Context, *cloudformation.ActivateTypeInput, ...func(*cloudformation.Options)) (*cloudformation.ActivateTypeOutput, error)) *CloudFormation_ActivateType_Call {
	_c.Call.Return(run)
	return _c
}

// BatchDescribeTypeConfigurations provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) BatchDescribeTypeConfigurations(ctx context.Context, params *cloudformation.BatchDescribeTypeConfigurationsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for BatchDescribeTypeConfigurations")
	}

	var r0 *cloudformation.BatchDescribeTypeConfigurationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.BatchDescribeTypeConfigurationsInput, ...func(*cloudformation.Options)) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.BatchDescribeTypeConfigurationsInput, ...func(*cloudformation.Options)) *cloudformation.BatchDescribeTypeConfigurationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.BatchDescribeTypeConfigurationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.BatchDescribeTypeConfigurationsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_BatchDescribeTypeConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BatchDescribeTypeConfigurations'
type CloudFormation_BatchDescribeTypeConfigurations_Call struct {
	*mock.Call
}

// BatchDescribeTypeConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.BatchDescribeTypeConfigurationsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) BatchDescribeTypeConfigurations(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_BatchDescribeTypeConfigurations_Call {
	return &CloudFormation_BatchDescribeTypeConfigurations_Call{Call: _e.mock.On("BatchDescribeTypeConfigurations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_BatchDescribeTypeConfigurations_Call) Run(run func(ctx context.Context, params *cloudformation.BatchDescribeTypeConfigurationsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_BatchDescribeTypeConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.BatchDescribeTypeConfigurationsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_BatchDescribeTypeConfigurations_Call) Return(_a0 *cloudformation.BatchDescribeTypeConfigurationsOutput, _a1 error) *CloudFormation_BatchDescribeTypeConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_BatchDescribeTypeConfigurations_Call) RunAndReturn(run func(context.Context, *cloudformation.BatchDescribeTypeConfigurationsInput, ...func(*cloudformation.Options)) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error)) *CloudFormation_BatchDescribeTypeConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// CancelUpdateStack provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CancelUpdateStack(ctx context.Context, params *cloudformation.CancelUpdateStackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CancelUpdateStackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CancelUpdateStack")
	}

	var r0 *cloudformation.CancelUpdateStackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CancelUpdateStackInput, ...func(*cloudformation.Options)) (*cloudformation.CancelUpdateStackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CancelUpdateStackInput, ...func(*cloudformation.Options)) *cloudformation.CancelUpdateStackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CancelUpdateStackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CancelUpdateStackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CancelUpdateStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelUpdateStack'
type CloudFormation_CancelUpdateStack_Call struct {
	*mock.Call
}

// CancelUpdateStack is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CancelUpdateStackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CancelUpdateStack(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CancelUpdateStack_Call {
	return &CloudFormation_CancelUpdateStack_Call{Call: _e.mock.On("CancelUpdateStack",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CancelUpdateStack_Call) Run(run func(ctx context.Context, params *cloudformation.CancelUpdateStackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CancelUpdateStack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CancelUpdateStackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CancelUpdateStack_Call) Return(_a0 *cloudformation.CancelUpdateStackOutput, _a1 error) *CloudFormation_CancelUpdateStack_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CancelUpdateStack_Call) RunAndReturn(run func(context.Context, *cloudformation.CancelUpdateStackInput, ...func(*cloudformation.Options)) (*cloudformation.CancelUpdateStackOutput, error)) *CloudFormation_CancelUpdateStack_Call {
	_c.Call.Return(run)
	return _c
}

// ContinueUpdateRollback provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ContinueUpdateRollback(ctx context.Context, params *cloudformation.ContinueUpdateRollbackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ContinueUpdateRollbackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ContinueUpdateRollback")
	}

	var r0 *cloudformation.ContinueUpdateRollbackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ContinueUpdateRollbackInput, ...func(*cloudformation.Options)) (*cloudformation.ContinueUpdateRollbackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ContinueUpdateRollbackInput, ...func(*cloudformation.Options)) *cloudformation.ContinueUpdateRollbackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ContinueUpdateRollbackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ContinueUpdateRollbackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ContinueUpdateRollback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContinueUpdateRollback'
type CloudFormation_ContinueUpdateRollback_Call struct {
	*mock.Call
}

// ContinueUpdateRollback is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ContinueUpdateRollbackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ContinueUpdateRollback(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ContinueUpdateRollback_Call {
	return &CloudFormation_ContinueUpdateRollback_Call{Call: _e.mock.On("ContinueUpdateRollback",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ContinueUpdateRollback_Call) Run(run func(ctx context.Context, params *cloudformation.ContinueUpdateRollbackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ContinueUpdateRollback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ContinueUpdateRollbackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ContinueUpdateRollback_Call) Return(_a0 *cloudformation.ContinueUpdateRollbackOutput, _a1 error) *CloudFormation_ContinueUpdateRollback_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ContinueUpdateRollback_Call) RunAndReturn(run func(context.Context, *cloudformation.ContinueUpdateRollbackInput, ...func(*cloudformation.Options)) (*cloudformation.ContinueUpdateRollbackOutput, error)) *CloudFormation_ContinueUpdateRollback_Call {
	_c.Call.Return(run)
	return _c
}

// CreateChangeSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateChangeSet(ctx context.Context, params *cloudformation.CreateChangeSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateChangeSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateChangeSet")
	}

	var r0 *cloudformation.CreateChangeSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.CreateChangeSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateChangeSetInput, ...func(*cloudformation.Options)) *cloudformation.CreateChangeSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateChangeSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateChangeSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateChangeSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChangeSet'
type CloudFormation_CreateChangeSet_Call struct {
	*mock.Call
}

// CreateChangeSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateChangeSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateChangeSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateChangeSet_Call {
	return &CloudFormation_CreateChangeSet_Call{Call: _e.mock.On("CreateChangeSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateChangeSet_Call) Run(run func(ctx context.Context, params *cloudformation.CreateChangeSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateChangeSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateChangeSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateChangeSet_Call) Return(_a0 *cloudformation.CreateChangeSetOutput, _a1 error) *CloudFormation_CreateChangeSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateChangeSet_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.CreateChangeSetOutput, error)) *CloudFormation_CreateChangeSet_Call {
	_c.Call.Return(run)
	return _c
}

// CreateGeneratedTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateGeneratedTemplate(ctx context.Context, params *cloudformation.CreateGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateGeneratedTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateGeneratedTemplate")
	}

	var r0 *cloudformation.CreateGeneratedTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.CreateGeneratedTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateGeneratedTemplateInput, ...func(*cloudformation.Options)) *cloudformation.CreateGeneratedTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateGeneratedTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateGeneratedTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateGeneratedTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGeneratedTemplate'
type CloudFormation_CreateGeneratedTemplate_Call struct {
	*mock.Call
}

// CreateGeneratedTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateGeneratedTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateGeneratedTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateGeneratedTemplate_Call {
	return &CloudFormation_CreateGeneratedTemplate_Call{Call: _e.mock.On("CreateGeneratedTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateGeneratedTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.CreateGeneratedTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateGeneratedTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateGeneratedTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateGeneratedTemplate_Call) Return(_a0 *cloudformation.CreateGeneratedTemplateOutput, _a1 error) *CloudFormation_CreateGeneratedTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateGeneratedTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.CreateGeneratedTemplateOutput, error)) *CloudFormation_CreateGeneratedTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStack provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateStack(ctx context.Context, params *cloudformation.CreateStackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateStackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateStack")
	}

	var r0 *cloudformation.CreateStackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackInput, ...func(*cloudformation.Options)) *cloudformation.CreateStackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateStackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStack'
type CloudFormation_CreateStack_Call struct {
	*mock.Call
}

// CreateStack is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateStackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateStack(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateStack_Call {
	return &CloudFormation_CreateStack_Call{Call: _e.mock.On("CreateStack",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateStack_Call) Run(run func(ctx context.Context, params *cloudformation.CreateStackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateStack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateStackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateStack_Call) Return(_a0 *cloudformation.CreateStackOutput, _a1 error) *CloudFormation_CreateStack_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateStack_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateStackInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackOutput, error)) *CloudFormation_CreateStack_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStackInstances provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateStackInstances(ctx context.Context, params *cloudformation.CreateStackInstancesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateStackInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateStackInstances")
	}

	var r0 *cloudformation.CreateStackInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackInstancesInput, ...func(*cloudformation.Options)) *cloudformation.CreateStackInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateStackInstancesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateStackInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStackInstances'
type CloudFormation_CreateStackInstances_Call struct {
	*mock.Call
}

// CreateStackInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateStackInstancesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateStackInstances(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateStackInstances_Call {
	return &CloudFormation_CreateStackInstances_Call{Call: _e.mock.On("CreateStackInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateStackInstances_Call) Run(run func(ctx context.Context, params *cloudformation.CreateStackInstancesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateStackInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateStackInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateStackInstances_Call) Return(_a0 *cloudformation.CreateStackInstancesOutput, _a1 error) *CloudFormation_CreateStackInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateStackInstances_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackInstancesOutput, error)) *CloudFormation_CreateStackInstances_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStackRefactor provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateStackRefactor(ctx context.Context, params *cloudformation.CreateStackRefactorInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateStackRefactorOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateStackRefactor")
	}

	var r0 *cloudformation.CreateStackRefactorOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackRefactorOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackRefactorInput, ...func(*cloudformation.Options)) *cloudformation.CreateStackRefactorOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackRefactorOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateStackRefactorInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateStackRefactor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStackRefactor'
type CloudFormation_CreateStackRefactor_Call struct {
	*mock.Call
}

// CreateStackRefactor is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateStackRefactorInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateStackRefactor(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateStackRefactor_Call {
	return &CloudFormation_CreateStackRefactor_Call{Call: _e.mock.On("CreateStackRefactor",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateStackRefactor_Call) Run(run func(ctx context.Context, params *cloudformation.CreateStackRefactorInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateStackRefactor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateStackRefactorInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateStackRefactor_Call) Return(_a0 *cloudformation.CreateStackRefactorOutput, _a1 error) *CloudFormation_CreateStackRefactor_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateStackRefactor_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackRefactorOutput, error)) *CloudFormation_CreateStackRefactor_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStackSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) CreateStackSet(ctx context.Context, params *cloudformation.CreateStackSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.CreateStackSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateStackSet")
	}

	var r0 *cloudformation.CreateStackSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.CreateStackSetInput, ...func(*cloudformation.Options)) *cloudformation.CreateStackSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.CreateStackSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.CreateStackSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_CreateStackSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStackSet'
type CloudFormation_CreateStackSet_Call struct {
	*mock.Call
}

// CreateStackSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.CreateStackSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) CreateStackSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_CreateStackSet_Call {
	return &CloudFormation_CreateStackSet_Call{Call: _e.mock.On("CreateStackSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_CreateStackSet_Call) Run(run func(ctx context.Context, params *cloudformation.CreateStackSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_CreateStackSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.CreateStackSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_CreateStackSet_Call) Return(_a0 *cloudformation.CreateStackSetOutput, _a1 error) *CloudFormation_CreateStackSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_CreateStackSet_Call) RunAndReturn(run func(context.Context, *cloudformation.CreateStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.CreateStackSetOutput, error)) *CloudFormation_CreateStackSet_Call {
	_c.Call.Return(run)
	return _c
}

// DeactivateOrganizationsAccess provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeactivateOrganizationsAccess(ctx context.Context, params *cloudformation.DeactivateOrganizationsAccessInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeactivateOrganizationsAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeactivateOrganizationsAccess")
	}

	var r0 *cloudformation.DeactivateOrganizationsAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeactivateOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.DeactivateOrganizationsAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeactivateOrganizationsAccessInput, ...func(*cloudformation.Options)) *cloudformation.DeactivateOrganizationsAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeactivateOrganizationsAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeactivateOrganizationsAccessInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeactivateOrganizationsAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateOrganizationsAccess'
type CloudFormation_DeactivateOrganizationsAccess_Call struct {
	*mock.Call
}

// DeactivateOrganizationsAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeactivateOrganizationsAccessInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeactivateOrganizationsAccess(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeactivateOrganizationsAccess_Call {
	return &CloudFormation_DeactivateOrganizationsAccess_Call{Call: _e.mock.On("DeactivateOrganizationsAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeactivateOrganizationsAccess_Call) Run(run func(ctx context.Context, params *cloudformation.DeactivateOrganizationsAccessInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeactivateOrganizationsAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeactivateOrganizationsAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeactivateOrganizationsAccess_Call) Return(_a0 *cloudformation.DeactivateOrganizationsAccessOutput, _a1 error) *CloudFormation_DeactivateOrganizationsAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeactivateOrganizationsAccess_Call) RunAndReturn(run func(context.Context, *cloudformation.DeactivateOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.DeactivateOrganizationsAccessOutput, error)) *CloudFormation_DeactivateOrganizationsAccess_Call {
	_c.Call.Return(run)
	return _c
}

// DeactivateType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeactivateType(ctx context.Context, params *cloudformation.DeactivateTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeactivateTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeactivateType")
	}

	var r0 *cloudformation.DeactivateTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeactivateTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DeactivateTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeactivateTypeInput, ...func(*cloudformation.Options)) *cloudformation.DeactivateTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeactivateTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeactivateTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeactivateType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeactivateType'
type CloudFormation_DeactivateType_Call struct {
	*mock.Call
}

// DeactivateType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeactivateTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeactivateType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeactivateType_Call {
	return &CloudFormation_DeactivateType_Call{Call: _e.mock.On("DeactivateType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeactivateType_Call) Run(run func(ctx context.Context, params *cloudformation.DeactivateTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeactivateType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeactivateTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeactivateType_Call) Return(_a0 *cloudformation.DeactivateTypeOutput, _a1 error) *CloudFormation_DeactivateType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeactivateType_Call) RunAndReturn(run func(context.Context, *cloudformation.DeactivateTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DeactivateTypeOutput, error)) *CloudFormation_DeactivateType_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteChangeSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeleteChangeSet(ctx context.Context, params *cloudformation.DeleteChangeSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeleteChangeSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteChangeSet")
	}

	var r0 *cloudformation.DeleteChangeSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteChangeSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteChangeSetInput, ...func(*cloudformation.Options)) *cloudformation.DeleteChangeSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteChangeSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeleteChangeSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeleteChangeSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChangeSet'
type CloudFormation_DeleteChangeSet_Call struct {
	*mock.Call
}

// DeleteChangeSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeleteChangeSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeleteChangeSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeleteChangeSet_Call {
	return &CloudFormation_DeleteChangeSet_Call{Call: _e.mock.On("DeleteChangeSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeleteChangeSet_Call) Run(run func(ctx context.Context, params *cloudformation.DeleteChangeSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeleteChangeSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeleteChangeSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeleteChangeSet_Call) Return(_a0 *cloudformation.DeleteChangeSetOutput, _a1 error) *CloudFormation_DeleteChangeSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeleteChangeSet_Call) RunAndReturn(run func(context.Context, *cloudformation.DeleteChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteChangeSetOutput, error)) *CloudFormation_DeleteChangeSet_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteGeneratedTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeleteGeneratedTemplate(ctx context.Context, params *cloudformation.DeleteGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeleteGeneratedTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteGeneratedTemplate")
	}

	var r0 *cloudformation.DeleteGeneratedTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteGeneratedTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteGeneratedTemplateInput, ...func(*cloudformation.Options)) *cloudformation.DeleteGeneratedTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteGeneratedTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeleteGeneratedTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeleteGeneratedTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGeneratedTemplate'
type CloudFormation_DeleteGeneratedTemplate_Call struct {
	*mock.Call
}

// DeleteGeneratedTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeleteGeneratedTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeleteGeneratedTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeleteGeneratedTemplate_Call {
	return &CloudFormation_DeleteGeneratedTemplate_Call{Call: _e.mock.On("DeleteGeneratedTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeleteGeneratedTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.DeleteGeneratedTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeleteGeneratedTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeleteGeneratedTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeleteGeneratedTemplate_Call) Return(_a0 *cloudformation.DeleteGeneratedTemplateOutput, _a1 error) *CloudFormation_DeleteGeneratedTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeleteGeneratedTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.DeleteGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteGeneratedTemplateOutput, error)) *CloudFormation_DeleteGeneratedTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteStack provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeleteStack(ctx context.Context, params *cloudformation.DeleteStackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeleteStackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteStack")
	}

	var r0 *cloudformation.DeleteStackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackInput, ...func(*cloudformation.Options)) *cloudformation.DeleteStackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeleteStackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeleteStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStack'
type CloudFormation_DeleteStack_Call struct {
	*mock.Call
}

// DeleteStack is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeleteStackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeleteStack(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeleteStack_Call {
	return &CloudFormation_DeleteStack_Call{Call: _e.mock.On("DeleteStack",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeleteStack_Call) Run(run func(ctx context.Context, params *cloudformation.DeleteStackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeleteStack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeleteStackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeleteStack_Call) Return(_a0 *cloudformation.DeleteStackOutput, _a1 error) *CloudFormation_DeleteStack_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeleteStack_Call) RunAndReturn(run func(context.Context, *cloudformation.DeleteStackInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackOutput, error)) *CloudFormation_DeleteStack_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteStackInstances provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeleteStackInstances(ctx context.Context, params *cloudformation.DeleteStackInstancesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeleteStackInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteStackInstances")
	}

	var r0 *cloudformation.DeleteStackInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackInstancesInput, ...func(*cloudformation.Options)) *cloudformation.DeleteStackInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeleteStackInstancesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeleteStackInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStackInstances'
type CloudFormation_DeleteStackInstances_Call struct {
	*mock.Call
}

// DeleteStackInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeleteStackInstancesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeleteStackInstances(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeleteStackInstances_Call {
	return &CloudFormation_DeleteStackInstances_Call{Call: _e.mock.On("DeleteStackInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeleteStackInstances_Call) Run(run func(ctx context.Context, params *cloudformation.DeleteStackInstancesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeleteStackInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeleteStackInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeleteStackInstances_Call) Return(_a0 *cloudformation.DeleteStackInstancesOutput, _a1 error) *CloudFormation_DeleteStackInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeleteStackInstances_Call) RunAndReturn(run func(context.Context, *cloudformation.DeleteStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackInstancesOutput, error)) *CloudFormation_DeleteStackInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteStackSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeleteStackSet(ctx context.Context, params *cloudformation.DeleteStackSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeleteStackSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteStackSet")
	}

	var r0 *cloudformation.DeleteStackSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeleteStackSetInput, ...func(*cloudformation.Options)) *cloudformation.DeleteStackSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeleteStackSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeleteStackSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeleteStackSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStackSet'
type CloudFormation_DeleteStackSet_Call struct {
	*mock.Call
}

// DeleteStackSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeleteStackSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeleteStackSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeleteStackSet_Call {
	return &CloudFormation_DeleteStackSet_Call{Call: _e.mock.On("DeleteStackSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeleteStackSet_Call) Run(run func(ctx context.Context, params *cloudformation.DeleteStackSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeleteStackSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeleteStackSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeleteStackSet_Call) Return(_a0 *cloudformation.DeleteStackSetOutput, _a1 error) *CloudFormation_DeleteStackSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeleteStackSet_Call) RunAndReturn(run func(context.Context, *cloudformation.DeleteStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.DeleteStackSetOutput, error)) *CloudFormation_DeleteStackSet_Call {
	_c.Call.Return(run)
	return _c
}

// DeregisterType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DeregisterType(ctx context.Context, params *cloudformation.DeregisterTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DeregisterTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeregisterType")
	}

	var r0 *cloudformation.DeregisterTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeregisterTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DeregisterTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DeregisterTypeInput, ...func(*cloudformation.Options)) *cloudformation.DeregisterTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DeregisterTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DeregisterTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DeregisterType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeregisterType'
type CloudFormation_DeregisterType_Call struct {
	*mock.Call
}

// DeregisterType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DeregisterTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DeregisterType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DeregisterType_Call {
	return &CloudFormation_DeregisterType_Call{Call: _e.mock.On("DeregisterType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DeregisterType_Call) Run(run func(ctx context.Context, params *cloudformation.DeregisterTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DeregisterType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DeregisterTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DeregisterType_Call) Return(_a0 *cloudformation.DeregisterTypeOutput, _a1 error) *CloudFormation_DeregisterType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DeregisterType_Call) RunAndReturn(run func(context.Context, *cloudformation.DeregisterTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DeregisterTypeOutput, error)) *CloudFormation_DeregisterType_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeAccountLimits provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeAccountLimits(ctx context.Context, params *cloudformation.DescribeAccountLimitsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeAccountLimitsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeAccountLimits")
	}

	var r0 *cloudformation.DescribeAccountLimitsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeAccountLimitsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeAccountLimitsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeAccountLimitsInput, ...func(*cloudformation.Options)) *cloudformation.DescribeAccountLimitsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeAccountLimitsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeAccountLimitsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeAccountLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAccountLimits'
type CloudFormation_DescribeAccountLimits_Call struct {
	*mock.Call
}

// DescribeAccountLimits is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeAccountLimitsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeAccountLimits(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeAccountLimits_Call {
	return &CloudFormation_DescribeAccountLimits_Call{Call: _e.mock.On("DescribeAccountLimits",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeAccountLimits_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeAccountLimitsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeAccountLimits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeAccountLimitsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeAccountLimits_Call) Return(_a0 *cloudformation.DescribeAccountLimitsOutput, _a1 error) *CloudFormation_DescribeAccountLimits_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeAccountLimits_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeAccountLimitsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeAccountLimitsOutput, error)) *CloudFormation_DescribeAccountLimits_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeChangeSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeChangeSet(ctx context.Context, params *cloudformation.DescribeChangeSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeChangeSet")
	}

	var r0 *cloudformation.DescribeChangeSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeChangeSetInput, ...func(*cloudformation.Options)) *cloudformation.DescribeChangeSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeChangeSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeChangeSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeChangeSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeChangeSet'
type CloudFormation_DescribeChangeSet_Call struct {
	*mock.Call
}

// DescribeChangeSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeChangeSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeChangeSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeChangeSet_Call {
	return &CloudFormation_DescribeChangeSet_Call{Call: _e.mock.On("DescribeChangeSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeChangeSet_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeChangeSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeChangeSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeChangeSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeChangeSet_Call) Return(_a0 *cloudformation.DescribeChangeSetOutput, _a1 error) *CloudFormation_DescribeChangeSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeChangeSet_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetOutput, error)) *CloudFormation_DescribeChangeSet_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeChangeSetHooks provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeChangeSetHooks(ctx context.Context, params *cloudformation.DescribeChangeSetHooksInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetHooksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeChangeSetHooks")
	}

	var r0 *cloudformation.DescribeChangeSetHooksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeChangeSetHooksInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetHooksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeChangeSetHooksInput, ...func(*cloudformation.Options)) *cloudformation.DescribeChangeSetHooksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeChangeSetHooksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeChangeSetHooksInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeChangeSetHooks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeChangeSetHooks'
type CloudFormation_DescribeChangeSetHooks_Call struct {
	*mock.Call
}

// DescribeChangeSetHooks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeChangeSetHooksInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeChangeSetHooks(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeChangeSetHooks_Call {
	return &CloudFormation_DescribeChangeSetHooks_Call{Call: _e.mock.On("DescribeChangeSetHooks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeChangeSetHooks_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeChangeSetHooksInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeChangeSetHooks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeChangeSetHooksInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeChangeSetHooks_Call) Return(_a0 *cloudformation.DescribeChangeSetHooksOutput, _a1 error) *CloudFormation_DescribeChangeSetHooks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeChangeSetHooks_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeChangeSetHooksInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeChangeSetHooksOutput, error)) *CloudFormation_DescribeChangeSetHooks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeGeneratedTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeGeneratedTemplate(ctx context.Context, params *cloudformation.DescribeGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeGeneratedTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeGeneratedTemplate")
	}

	var r0 *cloudformation.DescribeGeneratedTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeGeneratedTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeGeneratedTemplateInput, ...func(*cloudformation.Options)) *cloudformation.DescribeGeneratedTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeGeneratedTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeGeneratedTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeGeneratedTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeGeneratedTemplate'
type CloudFormation_DescribeGeneratedTemplate_Call struct {
	*mock.Call
}

// DescribeGeneratedTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeGeneratedTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeGeneratedTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeGeneratedTemplate_Call {
	return &CloudFormation_DescribeGeneratedTemplate_Call{Call: _e.mock.On("DescribeGeneratedTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeGeneratedTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeGeneratedTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeGeneratedTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeGeneratedTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeGeneratedTemplate_Call) Return(_a0 *cloudformation.DescribeGeneratedTemplateOutput, _a1 error) *CloudFormation_DescribeGeneratedTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeGeneratedTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeGeneratedTemplateOutput, error)) *CloudFormation_DescribeGeneratedTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeOrganizationsAccess provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeOrganizationsAccess(ctx context.Context, params *cloudformation.DescribeOrganizationsAccessInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeOrganizationsAccessOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeOrganizationsAccess")
	}

	var r0 *cloudformation.DescribeOrganizationsAccessOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeOrganizationsAccessOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeOrganizationsAccessInput, ...func(*cloudformation.Options)) *cloudformation.DescribeOrganizationsAccessOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeOrganizationsAccessOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeOrganizationsAccessInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeOrganizationsAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeOrganizationsAccess'
type CloudFormation_DescribeOrganizationsAccess_Call struct {
	*mock.Call
}

// DescribeOrganizationsAccess is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeOrganizationsAccessInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeOrganizationsAccess(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeOrganizationsAccess_Call {
	return &CloudFormation_DescribeOrganizationsAccess_Call{Call: _e.mock.On("DescribeOrganizationsAccess",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeOrganizationsAccess_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeOrganizationsAccessInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeOrganizationsAccess_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeOrganizationsAccessInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeOrganizationsAccess_Call) Return(_a0 *cloudformation.DescribeOrganizationsAccessOutput, _a1 error) *CloudFormation_DescribeOrganizationsAccess_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeOrganizationsAccess_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeOrganizationsAccessInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeOrganizationsAccessOutput, error)) *CloudFormation_DescribeOrganizationsAccess_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePublisher provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribePublisher(ctx context.Context, params *cloudformation.DescribePublisherInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribePublisherOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribePublisher")
	}

	var r0 *cloudformation.DescribePublisherOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribePublisherInput, ...func(*cloudformation.Options)) (*cloudformation.DescribePublisherOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribePublisherInput, ...func(*cloudformation.Options)) *cloudformation.DescribePublisherOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribePublisherOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribePublisherInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribePublisher_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribePublisher'
type CloudFormation_DescribePublisher_Call struct {
	*mock.Call
}

// DescribePublisher is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribePublisherInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribePublisher(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribePublisher_Call {
	return &CloudFormation_DescribePublisher_Call{Call: _e.mock.On("DescribePublisher",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribePublisher_Call) Run(run func(ctx context.Context, params *cloudformation.DescribePublisherInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribePublisher_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribePublisherInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribePublisher_Call) Return(_a0 *cloudformation.DescribePublisherOutput, _a1 error) *CloudFormation_DescribePublisher_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribePublisher_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribePublisherInput, ...func(*cloudformation.Options)) (*cloudformation.DescribePublisherOutput, error)) *CloudFormation_DescribePublisher_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeResourceScan provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeResourceScan(ctx context.Context, params *cloudformation.DescribeResourceScanInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeResourceScanOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeResourceScan")
	}

	var r0 *cloudformation.DescribeResourceScanOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeResourceScanInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeResourceScanOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeResourceScanInput, ...func(*cloudformation.Options)) *cloudformation.DescribeResourceScanOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeResourceScanOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeResourceScanInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeResourceScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeResourceScan'
type CloudFormation_DescribeResourceScan_Call struct {
	*mock.Call
}

// DescribeResourceScan is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeResourceScanInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeResourceScan(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeResourceScan_Call {
	return &CloudFormation_DescribeResourceScan_Call{Call: _e.mock.On("DescribeResourceScan",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeResourceScan_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeResourceScanInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeResourceScan_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeResourceScanInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeResourceScan_Call) Return(_a0 *cloudformation.DescribeResourceScanOutput, _a1 error) *CloudFormation_DescribeResourceScan_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeResourceScan_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeResourceScanInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeResourceScanOutput, error)) *CloudFormation_DescribeResourceScan_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackDriftDetectionStatus provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackDriftDetectionStatus(ctx context.Context, params *cloudformation.DescribeStackDriftDetectionStatusInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackDriftDetectionStatus")
	}

	var r0 *cloudformation.DescribeStackDriftDetectionStatusOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackDriftDetectionStatusInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackDriftDetectionStatusInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackDriftDetectionStatusOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackDriftDetectionStatusOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackDriftDetectionStatusInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackDriftDetectionStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackDriftDetectionStatus'
type CloudFormation_DescribeStackDriftDetectionStatus_Call struct {
	*mock.Call
}

// DescribeStackDriftDetectionStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackDriftDetectionStatusInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackDriftDetectionStatus(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackDriftDetectionStatus_Call {
	return &CloudFormation_DescribeStackDriftDetectionStatus_Call{Call: _e.mock.On("DescribeStackDriftDetectionStatus",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackDriftDetectionStatus_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackDriftDetectionStatusInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackDriftDetectionStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackDriftDetectionStatusInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackDriftDetectionStatus_Call) Return(_a0 *cloudformation.DescribeStackDriftDetectionStatusOutput, _a1 error) *CloudFormation_DescribeStackDriftDetectionStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackDriftDetectionStatus_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackDriftDetectionStatusInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error)) *CloudFormation_DescribeStackDriftDetectionStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackEvents provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackEvents(ctx context.Context, params *cloudformation.DescribeStackEventsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackEventsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackEvents")
	}

	var r0 *cloudformation.DescribeStackEventsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackEventsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackEventsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackEventsInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackEventsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackEventsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackEventsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackEvents'
type CloudFormation_DescribeStackEvents_Call struct {
	*mock.Call
}

// DescribeStackEvents is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackEventsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackEvents(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackEvents_Call {
	return &CloudFormation_DescribeStackEvents_Call{Call: _e.mock.On("DescribeStackEvents",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackEvents_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackEventsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackEventsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackEvents_Call) Return(_a0 *cloudformation.DescribeStackEventsOutput, _a1 error) *CloudFormation_DescribeStackEvents_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackEvents_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackEventsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackEventsOutput, error)) *CloudFormation_DescribeStackEvents_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackInstance provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackInstance(ctx context.Context, params *cloudformation.DescribeStackInstanceInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackInstanceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackInstance")
	}

	var r0 *cloudformation.DescribeStackInstanceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackInstanceInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackInstanceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackInstanceInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackInstanceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackInstanceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackInstanceInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackInstance'
type CloudFormation_DescribeStackInstance_Call struct {
	*mock.Call
}

// DescribeStackInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackInstanceInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackInstance(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackInstance_Call {
	return &CloudFormation_DescribeStackInstance_Call{Call: _e.mock.On("DescribeStackInstance",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackInstance_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackInstanceInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackInstanceInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackInstance_Call) Return(_a0 *cloudformation.DescribeStackInstanceOutput, _a1 error) *CloudFormation_DescribeStackInstance_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackInstance_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackInstanceInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackInstanceOutput, error)) *CloudFormation_DescribeStackInstance_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackRefactor provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackRefactor(ctx context.Context, params *cloudformation.DescribeStackRefactorInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackRefactorOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackRefactor")
	}

	var r0 *cloudformation.DescribeStackRefactorOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackRefactorOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackRefactorInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackRefactorOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackRefactorOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackRefactorInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackRefactor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackRefactor'
type CloudFormation_DescribeStackRefactor_Call struct {
	*mock.Call
}

// DescribeStackRefactor is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackRefactorInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackRefactor(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackRefactor_Call {
	return &CloudFormation_DescribeStackRefactor_Call{Call: _e.mock.On("DescribeStackRefactor",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackRefactor_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackRefactorInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackRefactor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackRefactorInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackRefactor_Call) Return(_a0 *cloudformation.DescribeStackRefactorOutput, _a1 error) *CloudFormation_DescribeStackRefactor_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackRefactor_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackRefactorOutput, error)) *CloudFormation_DescribeStackRefactor_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackResource provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackResource(ctx context.Context, params *cloudformation.DescribeStackResourceInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackResource")
	}

	var r0 *cloudformation.DescribeStackResourceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourceInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourceInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackResourceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackResourceInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackResource'
type CloudFormation_DescribeStackResource_Call struct {
	*mock.Call
}

// DescribeStackResource is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackResourceInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackResource(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackResource_Call {
	return &CloudFormation_DescribeStackResource_Call{Call: _e.mock.On("DescribeStackResource",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackResource_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackResourceInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackResourceInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackResource_Call) Return(_a0 *cloudformation.DescribeStackResourceOutput, _a1 error) *CloudFormation_DescribeStackResource_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackResource_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackResourceInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceOutput, error)) *CloudFormation_DescribeStackResource_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackResourceDrifts provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackResourceDrifts(ctx context.Context, params *cloudformation.DescribeStackResourceDriftsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceDriftsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackResourceDrifts")
	}

	var r0 *cloudformation.DescribeStackResourceDriftsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourceDriftsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceDriftsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourceDriftsInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackResourceDriftsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourceDriftsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackResourceDriftsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackResourceDrifts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackResourceDrifts'
type CloudFormation_DescribeStackResourceDrifts_Call struct {
	*mock.Call
}

// DescribeStackResourceDrifts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackResourceDriftsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackResourceDrifts(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackResourceDrifts_Call {
	return &CloudFormation_DescribeStackResourceDrifts_Call{Call: _e.mock.On("DescribeStackResourceDrifts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackResourceDrifts_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackResourceDriftsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackResourceDrifts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackResourceDriftsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackResourceDrifts_Call) Return(_a0 *cloudformation.DescribeStackResourceDriftsOutput, _a1 error) *CloudFormation_DescribeStackResourceDrifts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackResourceDrifts_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackResourceDriftsInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourceDriftsOutput, error)) *CloudFormation_DescribeStackResourceDrifts_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackResources provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackResources(ctx context.Context, params *cloudformation.DescribeStackResourcesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackResources")
	}

	var r0 *cloudformation.DescribeStackResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackResourcesInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackResourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackResourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackResourcesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackResources'
type CloudFormation_DescribeStackResources_Call struct {
	*mock.Call
}

// DescribeStackResources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackResourcesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackResources(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackResources_Call {
	return &CloudFormation_DescribeStackResources_Call{Call: _e.mock.On("DescribeStackResources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackResources_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackResourcesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackResourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackResources_Call) Return(_a0 *cloudformation.DescribeStackResourcesOutput, _a1 error) *CloudFormation_DescribeStackResources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackResources_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackResourcesOutput, error)) *CloudFormation_DescribeStackResources_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackSet(ctx context.Context, params *cloudformation.DescribeStackSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackSet")
	}

	var r0 *cloudformation.DescribeStackSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackSetInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackSet'
type CloudFormation_DescribeStackSet_Call struct {
	*mock.Call
}

// DescribeStackSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackSet_Call {
	return &CloudFormation_DescribeStackSet_Call{Call: _e.mock.On("DescribeStackSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackSet_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackSet_Call) Return(_a0 *cloudformation.DescribeStackSetOutput, _a1 error) *CloudFormation_DescribeStackSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackSet_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOutput, error)) *CloudFormation_DescribeStackSet_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStackSetOperation provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStackSetOperation(ctx context.Context, params *cloudformation.DescribeStackSetOperationInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOperationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStackSetOperation")
	}

	var r0 *cloudformation.DescribeStackSetOperationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackSetOperationInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOperationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStackSetOperationInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStackSetOperationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStackSetOperationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStackSetOperationInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStackSetOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStackSetOperation'
type CloudFormation_DescribeStackSetOperation_Call struct {
	*mock.Call
}

// DescribeStackSetOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStackSetOperationInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStackSetOperation(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStackSetOperation_Call {
	return &CloudFormation_DescribeStackSetOperation_Call{Call: _e.mock.On("DescribeStackSetOperation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStackSetOperation_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStackSetOperationInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStackSetOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStackSetOperationInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStackSetOperation_Call) Return(_a0 *cloudformation.DescribeStackSetOperationOutput, _a1 error) *CloudFormation_DescribeStackSetOperation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStackSetOperation_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStackSetOperationInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStackSetOperationOutput, error)) *CloudFormation_DescribeStackSetOperation_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeStacks provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeStacks(ctx context.Context, params *cloudformation.DescribeStacksInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeStacksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeStacks")
	}

	var r0 *cloudformation.DescribeStacksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStacksInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStacksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeStacksInput, ...func(*cloudformation.Options)) *cloudformation.DescribeStacksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeStacksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeStacksInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeStacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeStacks'
type CloudFormation_DescribeStacks_Call struct {
	*mock.Call
}

// DescribeStacks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeStacksInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeStacks(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeStacks_Call {
	return &CloudFormation_DescribeStacks_Call{Call: _e.mock.On("DescribeStacks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeStacks_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeStacksInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeStacks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeStacksInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeStacks_Call) Return(_a0 *cloudformation.DescribeStacksOutput, _a1 error) *CloudFormation_DescribeStacks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeStacks_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeStacksInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeStacksOutput, error)) *CloudFormation_DescribeStacks_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeType(ctx context.Context, params *cloudformation.DescribeTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeType")
	}

	var r0 *cloudformation.DescribeTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeTypeInput, ...func(*cloudformation.Options)) *cloudformation.DescribeTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeType'
type CloudFormation_DescribeType_Call struct {
	*mock.Call
}

// DescribeType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeType_Call {
	return &CloudFormation_DescribeType_Call{Call: _e.mock.On("DescribeType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeType_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeType_Call) Return(_a0 *cloudformation.DescribeTypeOutput, _a1 error) *CloudFormation_DescribeType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeType_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeTypeInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeOutput, error)) *CloudFormation_DescribeType_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTypeRegistration provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DescribeTypeRegistration(ctx context.Context, params *cloudformation.DescribeTypeRegistrationInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeRegistrationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DescribeTypeRegistration")
	}

	var r0 *cloudformation.DescribeTypeRegistrationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeTypeRegistrationInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeRegistrationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DescribeTypeRegistrationInput, ...func(*cloudformation.Options)) *cloudformation.DescribeTypeRegistrationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DescribeTypeRegistrationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DescribeTypeRegistrationInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DescribeTypeRegistration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeTypeRegistration'
type CloudFormation_DescribeTypeRegistration_Call struct {
	*mock.Call
}

// DescribeTypeRegistration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DescribeTypeRegistrationInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DescribeTypeRegistration(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DescribeTypeRegistration_Call {
	return &CloudFormation_DescribeTypeRegistration_Call{Call: _e.mock.On("DescribeTypeRegistration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DescribeTypeRegistration_Call) Run(run func(ctx context.Context, params *cloudformation.DescribeTypeRegistrationInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DescribeTypeRegistration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DescribeTypeRegistrationInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DescribeTypeRegistration_Call) Return(_a0 *cloudformation.DescribeTypeRegistrationOutput, _a1 error) *CloudFormation_DescribeTypeRegistration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DescribeTypeRegistration_Call) RunAndReturn(run func(context.Context, *cloudformation.DescribeTypeRegistrationInput, ...func(*cloudformation.Options)) (*cloudformation.DescribeTypeRegistrationOutput, error)) *CloudFormation_DescribeTypeRegistration_Call {
	_c.Call.Return(run)
	return _c
}

// DetectStackDrift provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DetectStackDrift(ctx context.Context, params *cloudformation.DetectStackDriftInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DetectStackDriftOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetectStackDrift")
	}

	var r0 *cloudformation.DetectStackDriftOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackDriftOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackDriftInput, ...func(*cloudformation.Options)) *cloudformation.DetectStackDriftOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackDriftOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DetectStackDriftInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DetectStackDrift_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectStackDrift'
type CloudFormation_DetectStackDrift_Call struct {
	*mock.Call
}

// DetectStackDrift is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DetectStackDriftInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DetectStackDrift(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DetectStackDrift_Call {
	return &CloudFormation_DetectStackDrift_Call{Call: _e.mock.On("DetectStackDrift",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DetectStackDrift_Call) Run(run func(ctx context.Context, params *cloudformation.DetectStackDriftInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DetectStackDrift_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DetectStackDriftInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DetectStackDrift_Call) Return(_a0 *cloudformation.DetectStackDriftOutput, _a1 error) *CloudFormation_DetectStackDrift_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DetectStackDrift_Call) RunAndReturn(run func(context.Context, *cloudformation.DetectStackDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackDriftOutput, error)) *CloudFormation_DetectStackDrift_Call {
	_c.Call.Return(run)
	return _c
}

// DetectStackResourceDrift provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DetectStackResourceDrift(ctx context.Context, params *cloudformation.DetectStackResourceDriftInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DetectStackResourceDriftOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetectStackResourceDrift")
	}

	var r0 *cloudformation.DetectStackResourceDriftOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackResourceDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackResourceDriftOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackResourceDriftInput, ...func(*cloudformation.Options)) *cloudformation.DetectStackResourceDriftOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackResourceDriftOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DetectStackResourceDriftInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DetectStackResourceDrift_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectStackResourceDrift'
type CloudFormation_DetectStackResourceDrift_Call struct {
	*mock.Call
}

// DetectStackResourceDrift is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DetectStackResourceDriftInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DetectStackResourceDrift(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DetectStackResourceDrift_Call {
	return &CloudFormation_DetectStackResourceDrift_Call{Call: _e.mock.On("DetectStackResourceDrift",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DetectStackResourceDrift_Call) Run(run func(ctx context.Context, params *cloudformation.DetectStackResourceDriftInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DetectStackResourceDrift_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DetectStackResourceDriftInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DetectStackResourceDrift_Call) Return(_a0 *cloudformation.DetectStackResourceDriftOutput, _a1 error) *CloudFormation_DetectStackResourceDrift_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DetectStackResourceDrift_Call) RunAndReturn(run func(context.Context, *cloudformation.DetectStackResourceDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackResourceDriftOutput, error)) *CloudFormation_DetectStackResourceDrift_Call {
	_c.Call.Return(run)
	return _c
}

// DetectStackSetDrift provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) DetectStackSetDrift(ctx context.Context, params *cloudformation.DetectStackSetDriftInput, optFns ...func(*cloudformation.Options)) (*cloudformation.DetectStackSetDriftOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DetectStackSetDrift")
	}

	var r0 *cloudformation.DetectStackSetDriftOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackSetDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackSetDriftOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.DetectStackSetDriftInput, ...func(*cloudformation.Options)) *cloudformation.DetectStackSetDriftOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.DetectStackSetDriftOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.DetectStackSetDriftInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_DetectStackSetDrift_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectStackSetDrift'
type CloudFormation_DetectStackSetDrift_Call struct {
	*mock.Call
}

// DetectStackSetDrift is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.DetectStackSetDriftInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) DetectStackSetDrift(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_DetectStackSetDrift_Call {
	return &CloudFormation_DetectStackSetDrift_Call{Call: _e.mock.On("DetectStackSetDrift",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_DetectStackSetDrift_Call) Run(run func(ctx context.Context, params *cloudformation.DetectStackSetDriftInput, optFns ...func(*cloudformation.Options))) *CloudFormation_DetectStackSetDrift_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.DetectStackSetDriftInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_DetectStackSetDrift_Call) Return(_a0 *cloudformation.DetectStackSetDriftOutput, _a1 error) *CloudFormation_DetectStackSetDrift_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_DetectStackSetDrift_Call) RunAndReturn(run func(context.Context, *cloudformation.DetectStackSetDriftInput, ...func(*cloudformation.Options)) (*cloudformation.DetectStackSetDriftOutput, error)) *CloudFormation_DetectStackSetDrift_Call {
	_c.Call.Return(run)
	return _c
}

// EstimateTemplateCost provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) EstimateTemplateCost(ctx context.Context, params *cloudformation.EstimateTemplateCostInput, optFns ...func(*cloudformation.Options)) (*cloudformation.EstimateTemplateCostOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EstimateTemplateCost")
	}

	var r0 *cloudformation.EstimateTemplateCostOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.EstimateTemplateCostInput, ...func(*cloudformation.Options)) (*cloudformation.EstimateTemplateCostOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.EstimateTemplateCostInput, ...func(*cloudformation.Options)) *cloudformation.EstimateTemplateCostOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.EstimateTemplateCostOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.EstimateTemplateCostInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_EstimateTemplateCost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateTemplateCost'
type CloudFormation_EstimateTemplateCost_Call struct {
	*mock.Call
}

// EstimateTemplateCost is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.EstimateTemplateCostInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) EstimateTemplateCost(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_EstimateTemplateCost_Call {
	return &CloudFormation_EstimateTemplateCost_Call{Call: _e.mock.On("EstimateTemplateCost",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_EstimateTemplateCost_Call) Run(run func(ctx context.Context, params *cloudformation.EstimateTemplateCostInput, optFns ...func(*cloudformation.Options))) *CloudFormation_EstimateTemplateCost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.EstimateTemplateCostInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_EstimateTemplateCost_Call) Return(_a0 *cloudformation.EstimateTemplateCostOutput, _a1 error) *CloudFormation_EstimateTemplateCost_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_EstimateTemplateCost_Call) RunAndReturn(run func(context.Context, *cloudformation.EstimateTemplateCostInput, ...func(*cloudformation.Options)) (*cloudformation.EstimateTemplateCostOutput, error)) *CloudFormation_EstimateTemplateCost_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteChangeSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ExecuteChangeSet(ctx context.Context, params *cloudformation.ExecuteChangeSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ExecuteChangeSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExecuteChangeSet")
	}

	var r0 *cloudformation.ExecuteChangeSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ExecuteChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.ExecuteChangeSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ExecuteChangeSetInput, ...func(*cloudformation.Options)) *cloudformation.ExecuteChangeSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ExecuteChangeSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ExecuteChangeSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ExecuteChangeSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteChangeSet'
type CloudFormation_ExecuteChangeSet_Call struct {
	*mock.Call
}

// ExecuteChangeSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ExecuteChangeSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ExecuteChangeSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ExecuteChangeSet_Call {
	return &CloudFormation_ExecuteChangeSet_Call{Call: _e.mock.On("ExecuteChangeSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ExecuteChangeSet_Call) Run(run func(ctx context.Context, params *cloudformation.ExecuteChangeSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ExecuteChangeSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ExecuteChangeSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ExecuteChangeSet_Call) Return(_a0 *cloudformation.ExecuteChangeSetOutput, _a1 error) *CloudFormation_ExecuteChangeSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ExecuteChangeSet_Call) RunAndReturn(run func(context.Context, *cloudformation.ExecuteChangeSetInput, ...func(*cloudformation.Options)) (*cloudformation.ExecuteChangeSetOutput, error)) *CloudFormation_ExecuteChangeSet_Call {
	_c.Call.Return(run)
	return _c
}

// ExecuteStackRefactor provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ExecuteStackRefactor(ctx context.Context, params *cloudformation.ExecuteStackRefactorInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ExecuteStackRefactorOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ExecuteStackRefactor")
	}

	var r0 *cloudformation.ExecuteStackRefactorOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ExecuteStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.ExecuteStackRefactorOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ExecuteStackRefactorInput, ...func(*cloudformation.Options)) *cloudformation.ExecuteStackRefactorOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ExecuteStackRefactorOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ExecuteStackRefactorInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ExecuteStackRefactor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteStackRefactor'
type CloudFormation_ExecuteStackRefactor_Call struct {
	*mock.Call
}

// ExecuteStackRefactor is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ExecuteStackRefactorInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ExecuteStackRefactor(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ExecuteStackRefactor_Call {
	return &CloudFormation_ExecuteStackRefactor_Call{Call: _e.mock.On("ExecuteStackRefactor",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ExecuteStackRefactor_Call) Run(run func(ctx context.Context, params *cloudformation.ExecuteStackRefactorInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ExecuteStackRefactor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ExecuteStackRefactorInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ExecuteStackRefactor_Call) Return(_a0 *cloudformation.ExecuteStackRefactorOutput, _a1 error) *CloudFormation_ExecuteStackRefactor_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ExecuteStackRefactor_Call) RunAndReturn(run func(context.Context, *cloudformation.ExecuteStackRefactorInput, ...func(*cloudformation.Options)) (*cloudformation.ExecuteStackRefactorOutput, error)) *CloudFormation_ExecuteStackRefactor_Call {
	_c.Call.Return(run)
	return _c
}

// GetGeneratedTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) GetGeneratedTemplate(ctx context.Context, params *cloudformation.GetGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetGeneratedTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetGeneratedTemplate")
	}

	var r0 *cloudformation.GetGeneratedTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.GetGeneratedTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetGeneratedTemplateInput, ...func(*cloudformation.Options)) *cloudformation.GetGeneratedTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetGeneratedTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.GetGeneratedTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_GetGeneratedTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGeneratedTemplate'
type CloudFormation_GetGeneratedTemplate_Call struct {
	*mock.Call
}

// GetGeneratedTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.GetGeneratedTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) GetGeneratedTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_GetGeneratedTemplate_Call {
	return &CloudFormation_GetGeneratedTemplate_Call{Call: _e.mock.On("GetGeneratedTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_GetGeneratedTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.GetGeneratedTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_GetGeneratedTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.GetGeneratedTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_GetGeneratedTemplate_Call) Return(_a0 *cloudformation.GetGeneratedTemplateOutput, _a1 error) *CloudFormation_GetGeneratedTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_GetGeneratedTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.GetGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.GetGeneratedTemplateOutput, error)) *CloudFormation_GetGeneratedTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetStackPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) GetStackPolicy(ctx context.Context, params *cloudformation.GetStackPolicyInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetStackPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetStackPolicy")
	}

	var r0 *cloudformation.GetStackPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetStackPolicyInput, ...func(*cloudformation.Options)) (*cloudformation.GetStackPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetStackPolicyInput, ...func(*cloudformation.Options)) *cloudformation.GetStackPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetStackPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.GetStackPolicyInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_GetStackPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStackPolicy'
type CloudFormation_GetStackPolicy_Call struct {
	*mock.Call
}

// GetStackPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.GetStackPolicyInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) GetStackPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_GetStackPolicy_Call {
	return &CloudFormation_GetStackPolicy_Call{Call: _e.mock.On("GetStackPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_GetStackPolicy_Call) Run(run func(ctx context.Context, params *cloudformation.GetStackPolicyInput, optFns ...func(*cloudformation.Options))) *CloudFormation_GetStackPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.GetStackPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_GetStackPolicy_Call) Return(_a0 *cloudformation.GetStackPolicyOutput, _a1 error) *CloudFormation_GetStackPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_GetStackPolicy_Call) RunAndReturn(run func(context.Context, *cloudformation.GetStackPolicyInput, ...func(*cloudformation.Options)) (*cloudformation.GetStackPolicyOutput, error)) *CloudFormation_GetStackPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// GetTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) GetTemplate(ctx context.Context, params *cloudformation.GetTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTemplate")
	}

	var r0 *cloudformation.GetTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.GetTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetTemplateInput, ...func(*cloudformation.Options)) *cloudformation.GetTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.GetTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_GetTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplate'
type CloudFormation_GetTemplate_Call struct {
	*mock.Call
}

// GetTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.GetTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) GetTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_GetTemplate_Call {
	return &CloudFormation_GetTemplate_Call{Call: _e.mock.On("GetTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_GetTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.GetTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_GetTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.GetTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_GetTemplate_Call) Return(_a0 *cloudformation.GetTemplateOutput, _a1 error) *CloudFormation_GetTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_GetTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.GetTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.GetTemplateOutput, error)) *CloudFormation_GetTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// GetTemplateSummary provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) GetTemplateSummary(ctx context.Context, params *cloudformation.GetTemplateSummaryInput, optFns ...func(*cloudformation.Options)) (*cloudformation.GetTemplateSummaryOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetTemplateSummary")
	}

	var r0 *cloudformation.GetTemplateSummaryOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetTemplateSummaryInput, ...func(*cloudformation.Options)) (*cloudformation.GetTemplateSummaryOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.GetTemplateSummaryInput, ...func(*cloudformation.Options)) *cloudformation.GetTemplateSummaryOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.GetTemplateSummaryOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.GetTemplateSummaryInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_GetTemplateSummary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplateSummary'
type CloudFormation_GetTemplateSummary_Call struct {
	*mock.Call
}

// GetTemplateSummary is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.GetTemplateSummaryInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) GetTemplateSummary(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_GetTemplateSummary_Call {
	return &CloudFormation_GetTemplateSummary_Call{Call: _e.mock.On("GetTemplateSummary",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_GetTemplateSummary_Call) Run(run func(ctx context.Context, params *cloudformation.GetTemplateSummaryInput, optFns ...func(*cloudformation.Options))) *CloudFormation_GetTemplateSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.GetTemplateSummaryInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_GetTemplateSummary_Call) Return(_a0 *cloudformation.GetTemplateSummaryOutput, _a1 error) *CloudFormation_GetTemplateSummary_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_GetTemplateSummary_Call) RunAndReturn(run func(context.Context, *cloudformation.GetTemplateSummaryInput, ...func(*cloudformation.Options)) (*cloudformation.GetTemplateSummaryOutput, error)) *CloudFormation_GetTemplateSummary_Call {
	_c.Call.Return(run)
	return _c
}

// ImportStacksToStackSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ImportStacksToStackSet(ctx context.Context, params *cloudformation.ImportStacksToStackSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ImportStacksToStackSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ImportStacksToStackSet")
	}

	var r0 *cloudformation.ImportStacksToStackSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.ImportStacksToStackSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...func(*cloudformation.Options)) *cloudformation.ImportStacksToStackSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ImportStacksToStackSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ImportStacksToStackSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportStacksToStackSet'
type CloudFormation_ImportStacksToStackSet_Call struct {
	*mock.Call
}

// ImportStacksToStackSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ImportStacksToStackSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ImportStacksToStackSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ImportStacksToStackSet_Call {
	return &CloudFormation_ImportStacksToStackSet_Call{Call: _e.mock.On("ImportStacksToStackSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ImportStacksToStackSet_Call) Run(run func(ctx context.Context, params *cloudformation.ImportStacksToStackSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ImportStacksToStackSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ImportStacksToStackSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ImportStacksToStackSet_Call) Return(_a0 *cloudformation.ImportStacksToStackSetOutput, _a1 error) *CloudFormation_ImportStacksToStackSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ImportStacksToStackSet_Call) RunAndReturn(run func(context.Context, *cloudformation.ImportStacksToStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.ImportStacksToStackSetOutput, error)) *CloudFormation_ImportStacksToStackSet_Call {
	_c.Call.Return(run)
	return _c
}

// ListChangeSets provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListChangeSets(ctx context.Context, params *cloudformation.ListChangeSetsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListChangeSetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListChangeSets")
	}

	var r0 *cloudformation.ListChangeSetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListChangeSetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListChangeSetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListChangeSetsInput, ...func(*cloudformation.Options)) *cloudformation.ListChangeSetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListChangeSetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListChangeSetsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListChangeSets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChangeSets'
type CloudFormation_ListChangeSets_Call struct {
	*mock.Call
}

// ListChangeSets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListChangeSetsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListChangeSets(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListChangeSets_Call {
	return &CloudFormation_ListChangeSets_Call{Call: _e.mock.On("ListChangeSets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListChangeSets_Call) Run(run func(ctx context.Context, params *cloudformation.ListChangeSetsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListChangeSets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListChangeSetsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListChangeSets_Call) Return(_a0 *cloudformation.ListChangeSetsOutput, _a1 error) *CloudFormation_ListChangeSets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListChangeSets_Call) RunAndReturn(run func(context.Context, *cloudformation.ListChangeSetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListChangeSetsOutput, error)) *CloudFormation_ListChangeSets_Call {
	_c.Call.Return(run)
	return _c
}

// ListExports provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListExports(ctx context.Context, params *cloudformation.ListExportsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListExportsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListExports")
	}

	var r0 *cloudformation.ListExportsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListExportsInput, ...func(*cloudformation.Options)) (*cloudformation.ListExportsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListExportsInput, ...func(*cloudformation.Options)) *cloudformation.ListExportsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListExportsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListExportsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListExports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExports'
type CloudFormation_ListExports_Call struct {
	*mock.Call
}

// ListExports is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListExportsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListExports(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListExports_Call {
	return &CloudFormation_ListExports_Call{Call: _e.mock.On("ListExports",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListExports_Call) Run(run func(ctx context.Context, params *cloudformation.ListExportsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListExports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListExportsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListExports_Call) Return(_a0 *cloudformation.ListExportsOutput, _a1 error) *CloudFormation_ListExports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListExports_Call) RunAndReturn(run func(context.Context, *cloudformation.ListExportsInput, ...func(*cloudformation.Options)) (*cloudformation.ListExportsOutput, error)) *CloudFormation_ListExports_Call {
	_c.Call.Return(run)
	return _c
}

// ListGeneratedTemplates provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListGeneratedTemplates(ctx context.Context, params *cloudformation.ListGeneratedTemplatesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListGeneratedTemplatesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListGeneratedTemplates")
	}

	var r0 *cloudformation.ListGeneratedTemplatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListGeneratedTemplatesInput, ...func(*cloudformation.Options)) (*cloudformation.ListGeneratedTemplatesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListGeneratedTemplatesInput, ...func(*cloudformation.Options)) *cloudformation.ListGeneratedTemplatesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListGeneratedTemplatesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListGeneratedTemplatesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListGeneratedTemplates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGeneratedTemplates'
type CloudFormation_ListGeneratedTemplates_Call struct {
	*mock.Call
}

// ListGeneratedTemplates is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListGeneratedTemplatesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListGeneratedTemplates(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListGeneratedTemplates_Call {
	return &CloudFormation_ListGeneratedTemplates_Call{Call: _e.mock.On("ListGeneratedTemplates",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListGeneratedTemplates_Call) Run(run func(ctx context.Context, params *cloudformation.ListGeneratedTemplatesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListGeneratedTemplates_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListGeneratedTemplatesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListGeneratedTemplates_Call) Return(_a0 *cloudformation.ListGeneratedTemplatesOutput, _a1 error) *CloudFormation_ListGeneratedTemplates_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListGeneratedTemplates_Call) RunAndReturn(run func(context.Context, *cloudformation.ListGeneratedTemplatesInput, ...func(*cloudformation.Options)) (*cloudformation.ListGeneratedTemplatesOutput, error)) *CloudFormation_ListGeneratedTemplates_Call {
	_c.Call.Return(run)
	return _c
}

// ListHookResults provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListHookResults(ctx context.Context, params *cloudformation.ListHookResultsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListHookResultsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListHookResults")
	}

	var r0 *cloudformation.ListHookResultsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListHookResultsInput, ...func(*cloudformation.Options)) (*cloudformation.ListHookResultsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListHookResultsInput, ...func(*cloudformation.Options)) *cloudformation.ListHookResultsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListHookResultsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListHookResultsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListHookResults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListHookResults'
type CloudFormation_ListHookResults_Call struct {
	*mock.Call
}

// ListHookResults is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListHookResultsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListHookResults(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListHookResults_Call {
	return &CloudFormation_ListHookResults_Call{Call: _e.mock.On("ListHookResults",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListHookResults_Call) Run(run func(ctx context.Context, params *cloudformation.ListHookResultsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListHookResults_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListHookResultsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListHookResults_Call) Return(_a0 *cloudformation.ListHookResultsOutput, _a1 error) *CloudFormation_ListHookResults_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListHookResults_Call) RunAndReturn(run func(context.Context, *cloudformation.ListHookResultsInput, ...func(*cloudformation.Options)) (*cloudformation.ListHookResultsOutput, error)) *CloudFormation_ListHookResults_Call {
	_c.Call.Return(run)
	return _c
}

// ListImports provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListImports(ctx context.Context, params *cloudformation.ListImportsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListImportsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListImports")
	}

	var r0 *cloudformation.ListImportsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListImportsInput, ...func(*cloudformation.Options)) (*cloudformation.ListImportsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListImportsInput, ...func(*cloudformation.Options)) *cloudformation.ListImportsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListImportsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListImportsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListImports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListImports'
type CloudFormation_ListImports_Call struct {
	*mock.Call
}

// ListImports is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListImportsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListImports(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListImports_Call {
	return &CloudFormation_ListImports_Call{Call: _e.mock.On("ListImports",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListImports_Call) Run(run func(ctx context.Context, params *cloudformation.ListImportsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListImports_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListImportsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListImports_Call) Return(_a0 *cloudformation.ListImportsOutput, _a1 error) *CloudFormation_ListImports_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListImports_Call) RunAndReturn(run func(context.Context, *cloudformation.ListImportsInput, ...func(*cloudformation.Options)) (*cloudformation.ListImportsOutput, error)) *CloudFormation_ListImports_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceScanRelatedResources provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListResourceScanRelatedResources(ctx context.Context, params *cloudformation.ListResourceScanRelatedResourcesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanRelatedResourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListResourceScanRelatedResources")
	}

	var r0 *cloudformation.ListResourceScanRelatedResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScanRelatedResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanRelatedResourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScanRelatedResourcesInput, ...func(*cloudformation.Options)) *cloudformation.ListResourceScanRelatedResourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListResourceScanRelatedResourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListResourceScanRelatedResourcesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListResourceScanRelatedResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListResourceScanRelatedResources'
type CloudFormation_ListResourceScanRelatedResources_Call struct {
	*mock.Call
}

// ListResourceScanRelatedResources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListResourceScanRelatedResourcesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListResourceScanRelatedResources(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListResourceScanRelatedResources_Call {
	return &CloudFormation_ListResourceScanRelatedResources_Call{Call: _e.mock.On("ListResourceScanRelatedResources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListResourceScanRelatedResources_Call) Run(run func(ctx context.Context, params *cloudformation.ListResourceScanRelatedResourcesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListResourceScanRelatedResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListResourceScanRelatedResourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListResourceScanRelatedResources_Call) Return(_a0 *cloudformation.ListResourceScanRelatedResourcesOutput, _a1 error) *CloudFormation_ListResourceScanRelatedResources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListResourceScanRelatedResources_Call) RunAndReturn(run func(context.Context, *cloudformation.ListResourceScanRelatedResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanRelatedResourcesOutput, error)) *CloudFormation_ListResourceScanRelatedResources_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceScanResources provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListResourceScanResources(ctx context.Context, params *cloudformation.ListResourceScanResourcesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanResourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListResourceScanResources")
	}

	var r0 *cloudformation.ListResourceScanResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScanResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanResourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScanResourcesInput, ...func(*cloudformation.Options)) *cloudformation.ListResourceScanResourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListResourceScanResourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListResourceScanResourcesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListResourceScanResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListResourceScanResources'
type CloudFormation_ListResourceScanResources_Call struct {
	*mock.Call
}

// ListResourceScanResources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListResourceScanResourcesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListResourceScanResources(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListResourceScanResources_Call {
	return &CloudFormation_ListResourceScanResources_Call{Call: _e.mock.On("ListResourceScanResources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListResourceScanResources_Call) Run(run func(ctx context.Context, params *cloudformation.ListResourceScanResourcesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListResourceScanResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListResourceScanResourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListResourceScanResources_Call) Return(_a0 *cloudformation.ListResourceScanResourcesOutput, _a1 error) *CloudFormation_ListResourceScanResources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListResourceScanResources_Call) RunAndReturn(run func(context.Context, *cloudformation.ListResourceScanResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScanResourcesOutput, error)) *CloudFormation_ListResourceScanResources_Call {
	_c.Call.Return(run)
	return _c
}

// ListResourceScans provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListResourceScans(ctx context.Context, params *cloudformation.ListResourceScansInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListResourceScansOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListResourceScans")
	}

	var r0 *cloudformation.ListResourceScansOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScansInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScansOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListResourceScansInput, ...func(*cloudformation.Options)) *cloudformation.ListResourceScansOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListResourceScansOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListResourceScansInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListResourceScans_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListResourceScans'
type CloudFormation_ListResourceScans_Call struct {
	*mock.Call
}

// ListResourceScans is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListResourceScansInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListResourceScans(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListResourceScans_Call {
	return &CloudFormation_ListResourceScans_Call{Call: _e.mock.On("ListResourceScans",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListResourceScans_Call) Run(run func(ctx context.Context, params *cloudformation.ListResourceScansInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListResourceScans_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListResourceScansInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListResourceScans_Call) Return(_a0 *cloudformation.ListResourceScansOutput, _a1 error) *CloudFormation_ListResourceScans_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListResourceScans_Call) RunAndReturn(run func(context.Context, *cloudformation.ListResourceScansInput, ...func(*cloudformation.Options)) (*cloudformation.ListResourceScansOutput, error)) *CloudFormation_ListResourceScans_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackInstanceResourceDrifts provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackInstanceResourceDrifts(ctx context.Context, params *cloudformation.ListStackInstanceResourceDriftsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackInstanceResourceDriftsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackInstanceResourceDrifts")
	}

	var r0 *cloudformation.ListStackInstanceResourceDriftsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackInstanceResourceDriftsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackInstanceResourceDriftsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackInstanceResourceDriftsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackInstanceResourceDriftsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackInstanceResourceDriftsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackInstanceResourceDriftsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackInstanceResourceDrifts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackInstanceResourceDrifts'
type CloudFormation_ListStackInstanceResourceDrifts_Call struct {
	*mock.Call
}

// ListStackInstanceResourceDrifts is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackInstanceResourceDriftsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackInstanceResourceDrifts(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackInstanceResourceDrifts_Call {
	return &CloudFormation_ListStackInstanceResourceDrifts_Call{Call: _e.mock.On("ListStackInstanceResourceDrifts",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackInstanceResourceDrifts_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackInstanceResourceDriftsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackInstanceResourceDrifts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackInstanceResourceDriftsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackInstanceResourceDrifts_Call) Return(_a0 *cloudformation.ListStackInstanceResourceDriftsOutput, _a1 error) *CloudFormation_ListStackInstanceResourceDrifts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackInstanceResourceDrifts_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackInstanceResourceDriftsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackInstanceResourceDriftsOutput, error)) *CloudFormation_ListStackInstanceResourceDrifts_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackInstances provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackInstances(ctx context.Context, params *cloudformation.ListStackInstancesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackInstances")
	}

	var r0 *cloudformation.ListStackInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackInstancesInput, ...func(*cloudformation.Options)) *cloudformation.ListStackInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackInstancesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackInstances'
type CloudFormation_ListStackInstances_Call struct {
	*mock.Call
}

// ListStackInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackInstancesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackInstances(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackInstances_Call {
	return &CloudFormation_ListStackInstances_Call{Call: _e.mock.On("ListStackInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackInstances_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackInstancesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackInstances_Call) Return(_a0 *cloudformation.ListStackInstancesOutput, _a1 error) *CloudFormation_ListStackInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackInstances_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackInstancesOutput, error)) *CloudFormation_ListStackInstances_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackRefactorActions provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackRefactorActions(ctx context.Context, params *cloudformation.ListStackRefactorActionsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorActionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackRefactorActions")
	}

	var r0 *cloudformation.ListStackRefactorActionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackRefactorActionsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorActionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackRefactorActionsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackRefactorActionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackRefactorActionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackRefactorActionsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackRefactorActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackRefactorActions'
type CloudFormation_ListStackRefactorActions_Call struct {
	*mock.Call
}

// ListStackRefactorActions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackRefactorActionsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackRefactorActions(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackRefactorActions_Call {
	return &CloudFormation_ListStackRefactorActions_Call{Call: _e.mock.On("ListStackRefactorActions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackRefactorActions_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackRefactorActionsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackRefactorActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackRefactorActionsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackRefactorActions_Call) Return(_a0 *cloudformation.ListStackRefactorActionsOutput, _a1 error) *CloudFormation_ListStackRefactorActions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackRefactorActions_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackRefactorActionsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorActionsOutput, error)) *CloudFormation_ListStackRefactorActions_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackRefactors provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackRefactors(ctx context.Context, params *cloudformation.ListStackRefactorsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackRefactors")
	}

	var r0 *cloudformation.ListStackRefactorsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackRefactorsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackRefactorsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackRefactorsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackRefactorsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackRefactorsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackRefactors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackRefactors'
type CloudFormation_ListStackRefactors_Call struct {
	*mock.Call
}

// ListStackRefactors is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackRefactorsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackRefactors(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackRefactors_Call {
	return &CloudFormation_ListStackRefactors_Call{Call: _e.mock.On("ListStackRefactors",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackRefactors_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackRefactorsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackRefactors_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackRefactorsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackRefactors_Call) Return(_a0 *cloudformation.ListStackRefactorsOutput, _a1 error) *CloudFormation_ListStackRefactors_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackRefactors_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackRefactorsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackRefactorsOutput, error)) *CloudFormation_ListStackRefactors_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackResources provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackResources(ctx context.Context, params *cloudformation.ListStackResourcesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackResourcesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackResources")
	}

	var r0 *cloudformation.ListStackResourcesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackResourcesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackResourcesInput, ...func(*cloudformation.Options)) *cloudformation.ListStackResourcesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackResourcesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackResourcesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackResources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackResources'
type CloudFormation_ListStackResources_Call struct {
	*mock.Call
}

// ListStackResources is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackResourcesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackResources(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackResources_Call {
	return &CloudFormation_ListStackResources_Call{Call: _e.mock.On("ListStackResources",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackResources_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackResourcesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackResources_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackResourcesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackResources_Call) Return(_a0 *cloudformation.ListStackResourcesOutput, _a1 error) *CloudFormation_ListStackResources_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackResources_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackResourcesInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackResourcesOutput, error)) *CloudFormation_ListStackResources_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackSetAutoDeploymentTargets provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackSetAutoDeploymentTargets(ctx context.Context, params *cloudformation.ListStackSetAutoDeploymentTargetsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackSetAutoDeploymentTargetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackSetAutoDeploymentTargets")
	}

	var r0 *cloudformation.ListStackSetAutoDeploymentTargetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetAutoDeploymentTargetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetAutoDeploymentTargetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetAutoDeploymentTargetsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackSetAutoDeploymentTargetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetAutoDeploymentTargetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackSetAutoDeploymentTargetsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackSetAutoDeploymentTargets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackSetAutoDeploymentTargets'
type CloudFormation_ListStackSetAutoDeploymentTargets_Call struct {
	*mock.Call
}

// ListStackSetAutoDeploymentTargets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackSetAutoDeploymentTargetsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackSetAutoDeploymentTargets(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackSetAutoDeploymentTargets_Call {
	return &CloudFormation_ListStackSetAutoDeploymentTargets_Call{Call: _e.mock.On("ListStackSetAutoDeploymentTargets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackSetAutoDeploymentTargets_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackSetAutoDeploymentTargetsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackSetAutoDeploymentTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackSetAutoDeploymentTargetsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackSetAutoDeploymentTargets_Call) Return(_a0 *cloudformation.ListStackSetAutoDeploymentTargetsOutput, _a1 error) *CloudFormation_ListStackSetAutoDeploymentTargets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackSetAutoDeploymentTargets_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackSetAutoDeploymentTargetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetAutoDeploymentTargetsOutput, error)) *CloudFormation_ListStackSetAutoDeploymentTargets_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackSetOperationResults provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackSetOperationResults(ctx context.Context, params *cloudformation.ListStackSetOperationResultsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationResultsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackSetOperationResults")
	}

	var r0 *cloudformation.ListStackSetOperationResultsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetOperationResultsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationResultsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetOperationResultsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackSetOperationResultsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetOperationResultsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackSetOperationResultsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackSetOperationResults_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackSetOperationResults'
type CloudFormation_ListStackSetOperationResults_Call struct {
	*mock.Call
}

// ListStackSetOperationResults is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackSetOperationResultsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackSetOperationResults(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackSetOperationResults_Call {
	return &CloudFormation_ListStackSetOperationResults_Call{Call: _e.mock.On("ListStackSetOperationResults",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackSetOperationResults_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackSetOperationResultsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackSetOperationResults_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackSetOperationResultsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackSetOperationResults_Call) Return(_a0 *cloudformation.ListStackSetOperationResultsOutput, _a1 error) *CloudFormation_ListStackSetOperationResults_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackSetOperationResults_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackSetOperationResultsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationResultsOutput, error)) *CloudFormation_ListStackSetOperationResults_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackSetOperations provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackSetOperations(ctx context.Context, params *cloudformation.ListStackSetOperationsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackSetOperations")
	}

	var r0 *cloudformation.ListStackSetOperationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetOperationsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetOperationsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackSetOperationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetOperationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackSetOperationsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackSetOperations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackSetOperations'
type CloudFormation_ListStackSetOperations_Call struct {
	*mock.Call
}

// ListStackSetOperations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackSetOperationsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackSetOperations(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackSetOperations_Call {
	return &CloudFormation_ListStackSetOperations_Call{Call: _e.mock.On("ListStackSetOperations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackSetOperations_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackSetOperationsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackSetOperations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackSetOperationsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackSetOperations_Call) Return(_a0 *cloudformation.ListStackSetOperationsOutput, _a1 error) *CloudFormation_ListStackSetOperations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackSetOperations_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackSetOperationsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetOperationsOutput, error)) *CloudFormation_ListStackSetOperations_Call {
	_c.Call.Return(run)
	return _c
}

// ListStackSets provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStackSets(ctx context.Context, params *cloudformation.ListStackSetsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStackSetsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStackSets")
	}

	var r0 *cloudformation.ListStackSetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStackSetsInput, ...func(*cloudformation.Options)) *cloudformation.ListStackSetsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStackSetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStackSetsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStackSets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStackSets'
type CloudFormation_ListStackSets_Call struct {
	*mock.Call
}

// ListStackSets is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStackSetsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStackSets(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStackSets_Call {
	return &CloudFormation_ListStackSets_Call{Call: _e.mock.On("ListStackSets",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStackSets_Call) Run(run func(ctx context.Context, params *cloudformation.ListStackSetsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStackSets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStackSetsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStackSets_Call) Return(_a0 *cloudformation.ListStackSetsOutput, _a1 error) *CloudFormation_ListStackSets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStackSets_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStackSetsInput, ...func(*cloudformation.Options)) (*cloudformation.ListStackSetsOutput, error)) *CloudFormation_ListStackSets_Call {
	_c.Call.Return(run)
	return _c
}

// ListStacks provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListStacks(ctx context.Context, params *cloudformation.ListStacksInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListStacksOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListStacks")
	}

	var r0 *cloudformation.ListStacksOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStacksInput, ...func(*cloudformation.Options)) (*cloudformation.ListStacksOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListStacksInput, ...func(*cloudformation.Options)) *cloudformation.ListStacksOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListStacksOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListStacksInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListStacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStacks'
type CloudFormation_ListStacks_Call struct {
	*mock.Call
}

// ListStacks is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListStacksInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListStacks(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListStacks_Call {
	return &CloudFormation_ListStacks_Call{Call: _e.mock.On("ListStacks",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListStacks_Call) Run(run func(ctx context.Context, params *cloudformation.ListStacksInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListStacks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListStacksInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListStacks_Call) Return(_a0 *cloudformation.ListStacksOutput, _a1 error) *CloudFormation_ListStacks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListStacks_Call) RunAndReturn(run func(context.Context, *cloudformation.ListStacksInput, ...func(*cloudformation.Options)) (*cloudformation.ListStacksOutput, error)) *CloudFormation_ListStacks_Call {
	_c.Call.Return(run)
	return _c
}

// ListTypeRegistrations provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListTypeRegistrations(ctx context.Context, params *cloudformation.ListTypeRegistrationsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListTypeRegistrationsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListTypeRegistrations")
	}

	var r0 *cloudformation.ListTypeRegistrationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypeRegistrationsInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypeRegistrationsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypeRegistrationsInput, ...func(*cloudformation.Options)) *cloudformation.ListTypeRegistrationsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypeRegistrationsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListTypeRegistrationsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListTypeRegistrations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTypeRegistrations'
type CloudFormation_ListTypeRegistrations_Call struct {
	*mock.Call
}

// ListTypeRegistrations is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListTypeRegistrationsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListTypeRegistrations(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListTypeRegistrations_Call {
	return &CloudFormation_ListTypeRegistrations_Call{Call: _e.mock.On("ListTypeRegistrations",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListTypeRegistrations_Call) Run(run func(ctx context.Context, params *cloudformation.ListTypeRegistrationsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListTypeRegistrations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListTypeRegistrationsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListTypeRegistrations_Call) Return(_a0 *cloudformation.ListTypeRegistrationsOutput, _a1 error) *CloudFormation_ListTypeRegistrations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListTypeRegistrations_Call) RunAndReturn(run func(context.Context, *cloudformation.ListTypeRegistrationsInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypeRegistrationsOutput, error)) *CloudFormation_ListTypeRegistrations_Call {
	_c.Call.Return(run)
	return _c
}

// ListTypeVersions provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListTypeVersions(ctx context.Context, params *cloudformation.ListTypeVersionsInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListTypeVersionsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListTypeVersions")
	}

	var r0 *cloudformation.ListTypeVersionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypeVersionsInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypeVersionsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypeVersionsInput, ...func(*cloudformation.Options)) *cloudformation.ListTypeVersionsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypeVersionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListTypeVersionsInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListTypeVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTypeVersions'
type CloudFormation_ListTypeVersions_Call struct {
	*mock.Call
}

// ListTypeVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListTypeVersionsInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListTypeVersions(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListTypeVersions_Call {
	return &CloudFormation_ListTypeVersions_Call{Call: _e.mock.On("ListTypeVersions",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListTypeVersions_Call) Run(run func(ctx context.Context, params *cloudformation.ListTypeVersionsInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListTypeVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListTypeVersionsInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListTypeVersions_Call) Return(_a0 *cloudformation.ListTypeVersionsOutput, _a1 error) *CloudFormation_ListTypeVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListTypeVersions_Call) RunAndReturn(run func(context.Context, *cloudformation.ListTypeVersionsInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypeVersionsOutput, error)) *CloudFormation_ListTypeVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListTypes provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ListTypes(ctx context.Context, params *cloudformation.ListTypesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ListTypesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListTypes")
	}

	var r0 *cloudformation.ListTypesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypesInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ListTypesInput, ...func(*cloudformation.Options)) *cloudformation.ListTypesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ListTypesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ListTypesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ListTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTypes'
type CloudFormation_ListTypes_Call struct {
	*mock.Call
}

// ListTypes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ListTypesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ListTypes(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ListTypes_Call {
	return &CloudFormation_ListTypes_Call{Call: _e.mock.On("ListTypes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ListTypes_Call) Run(run func(ctx context.Context, params *cloudformation.ListTypesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ListTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ListTypesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ListTypes_Call) Return(_a0 *cloudformation.ListTypesOutput, _a1 error) *CloudFormation_ListTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ListTypes_Call) RunAndReturn(run func(context.Context, *cloudformation.ListTypesInput, ...func(*cloudformation.Options)) (*cloudformation.ListTypesOutput, error)) *CloudFormation_ListTypes_Call {
	_c.Call.Return(run)
	return _c
}

// Options provides a mock function with no fields
func (_m *CloudFormation) Options() cloudformation.Options {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Options")
	}

	var r0 cloudformation.Options
	if rf, ok := ret.Get(0).(func() cloudformation.Options); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(cloudformation.Options)
	}

	return r0
}

// CloudFormation_Options_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Options'
type CloudFormation_Options_Call struct {
	*mock.Call
}

// Options is a helper method to define mock.On call
func (_e *CloudFormation_Expecter) Options() *CloudFormation_Options_Call {
	return &CloudFormation_Options_Call{Call: _e.mock.On("Options")}
}

func (_c *CloudFormation_Options_Call) Run(run func()) *CloudFormation_Options_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *CloudFormation_Options_Call) Return(_a0 cloudformation.Options) *CloudFormation_Options_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudFormation_Options_Call) RunAndReturn(run func() cloudformation.Options) *CloudFormation_Options_Call {
	_c.Call.Return(run)
	return _c
}

// PublishType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) PublishType(ctx context.Context, params *cloudformation.PublishTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.PublishTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PublishType")
	}

	var r0 *cloudformation.PublishTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.PublishTypeInput, ...func(*cloudformation.Options)) (*cloudformation.PublishTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.PublishTypeInput, ...func(*cloudformation.Options)) *cloudformation.PublishTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.PublishTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.PublishTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_PublishType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishType'
type CloudFormation_PublishType_Call struct {
	*mock.Call
}

// PublishType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.PublishTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) PublishType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_PublishType_Call {
	return &CloudFormation_PublishType_Call{Call: _e.mock.On("PublishType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_PublishType_Call) Run(run func(ctx context.Context, params *cloudformation.PublishTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_PublishType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.PublishTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_PublishType_Call) Return(_a0 *cloudformation.PublishTypeOutput, _a1 error) *CloudFormation_PublishType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_PublishType_Call) RunAndReturn(run func(context.Context, *cloudformation.PublishTypeInput, ...func(*cloudformation.Options)) (*cloudformation.PublishTypeOutput, error)) *CloudFormation_PublishType_Call {
	_c.Call.Return(run)
	return _c
}

// RecordHandlerProgress provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) RecordHandlerProgress(ctx context.Context, params *cloudformation.RecordHandlerProgressInput, optFns ...func(*cloudformation.Options)) (*cloudformation.RecordHandlerProgressOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RecordHandlerProgress")
	}

	var r0 *cloudformation.RecordHandlerProgressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RecordHandlerProgressInput, ...func(*cloudformation.Options)) (*cloudformation.RecordHandlerProgressOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RecordHandlerProgressInput, ...func(*cloudformation.Options)) *cloudformation.RecordHandlerProgressOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RecordHandlerProgressOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.RecordHandlerProgressInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_RecordHandlerProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordHandlerProgress'
type CloudFormation_RecordHandlerProgress_Call struct {
	*mock.Call
}

// RecordHandlerProgress is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.RecordHandlerProgressInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) RecordHandlerProgress(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_RecordHandlerProgress_Call {
	return &CloudFormation_RecordHandlerProgress_Call{Call: _e.mock.On("RecordHandlerProgress",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_RecordHandlerProgress_Call) Run(run func(ctx context.Context, params *cloudformation.RecordHandlerProgressInput, optFns ...func(*cloudformation.Options))) *CloudFormation_RecordHandlerProgress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.RecordHandlerProgressInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_RecordHandlerProgress_Call) Return(_a0 *cloudformation.RecordHandlerProgressOutput, _a1 error) *CloudFormation_RecordHandlerProgress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_RecordHandlerProgress_Call) RunAndReturn(run func(context.Context, *cloudformation.RecordHandlerProgressInput, ...func(*cloudformation.Options)) (*cloudformation.RecordHandlerProgressOutput, error)) *CloudFormation_RecordHandlerProgress_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterPublisher provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) RegisterPublisher(ctx context.Context, params *cloudformation.RegisterPublisherInput, optFns ...func(*cloudformation.Options)) (*cloudformation.RegisterPublisherOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterPublisher")
	}

	var r0 *cloudformation.RegisterPublisherOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RegisterPublisherInput, ...func(*cloudformation.Options)) (*cloudformation.RegisterPublisherOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RegisterPublisherInput, ...func(*cloudformation.Options)) *cloudformation.RegisterPublisherOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RegisterPublisherOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.RegisterPublisherInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_RegisterPublisher_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterPublisher'
type CloudFormation_RegisterPublisher_Call struct {
	*mock.Call
}

// RegisterPublisher is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.RegisterPublisherInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) RegisterPublisher(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_RegisterPublisher_Call {
	return &CloudFormation_RegisterPublisher_Call{Call: _e.mock.On("RegisterPublisher",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_RegisterPublisher_Call) Run(run func(ctx context.Context, params *cloudformation.RegisterPublisherInput, optFns ...func(*cloudformation.Options))) *CloudFormation_RegisterPublisher_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.RegisterPublisherInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_RegisterPublisher_Call) Return(_a0 *cloudformation.RegisterPublisherOutput, _a1 error) *CloudFormation_RegisterPublisher_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_RegisterPublisher_Call) RunAndReturn(run func(context.Context, *cloudformation.RegisterPublisherInput, ...func(*cloudformation.Options)) (*cloudformation.RegisterPublisherOutput, error)) *CloudFormation_RegisterPublisher_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) RegisterType(ctx context.Context, params *cloudformation.RegisterTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.RegisterTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RegisterType")
	}

	var r0 *cloudformation.RegisterTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RegisterTypeInput, ...func(*cloudformation.Options)) (*cloudformation.RegisterTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RegisterTypeInput, ...func(*cloudformation.Options)) *cloudformation.RegisterTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RegisterTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.RegisterTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_RegisterType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterType'
type CloudFormation_RegisterType_Call struct {
	*mock.Call
}

// RegisterType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.RegisterTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) RegisterType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_RegisterType_Call {
	return &CloudFormation_RegisterType_Call{Call: _e.mock.On("RegisterType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_RegisterType_Call) Run(run func(ctx context.Context, params *cloudformation.RegisterTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_RegisterType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.RegisterTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_RegisterType_Call) Return(_a0 *cloudformation.RegisterTypeOutput, _a1 error) *CloudFormation_RegisterType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_RegisterType_Call) RunAndReturn(run func(context.Context, *cloudformation.RegisterTypeInput, ...func(*cloudformation.Options)) (*cloudformation.RegisterTypeOutput, error)) *CloudFormation_RegisterType_Call {
	_c.Call.Return(run)
	return _c
}

// RollbackStack provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) RollbackStack(ctx context.Context, params *cloudformation.RollbackStackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.RollbackStackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RollbackStack")
	}

	var r0 *cloudformation.RollbackStackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RollbackStackInput, ...func(*cloudformation.Options)) (*cloudformation.RollbackStackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.RollbackStackInput, ...func(*cloudformation.Options)) *cloudformation.RollbackStackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.RollbackStackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.RollbackStackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_RollbackStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RollbackStack'
type CloudFormation_RollbackStack_Call struct {
	*mock.Call
}

// RollbackStack is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.RollbackStackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) RollbackStack(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_RollbackStack_Call {
	return &CloudFormation_RollbackStack_Call{Call: _e.mock.On("RollbackStack",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_RollbackStack_Call) Run(run func(ctx context.Context, params *cloudformation.RollbackStackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_RollbackStack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.RollbackStackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_RollbackStack_Call) Return(_a0 *cloudformation.RollbackStackOutput, _a1 error) *CloudFormation_RollbackStack_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_RollbackStack_Call) RunAndReturn(run func(context.Context, *cloudformation.RollbackStackInput, ...func(*cloudformation.Options)) (*cloudformation.RollbackStackOutput, error)) *CloudFormation_RollbackStack_Call {
	_c.Call.Return(run)
	return _c
}

// SetStackPolicy provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) SetStackPolicy(ctx context.Context, params *cloudformation.SetStackPolicyInput, optFns ...func(*cloudformation.Options)) (*cloudformation.SetStackPolicyOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SetStackPolicy")
	}

	var r0 *cloudformation.SetStackPolicyOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetStackPolicyInput, ...func(*cloudformation.Options)) (*cloudformation.SetStackPolicyOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetStackPolicyInput, ...func(*cloudformation.Options)) *cloudformation.SetStackPolicyOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetStackPolicyOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.SetStackPolicyInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_SetStackPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStackPolicy'
type CloudFormation_SetStackPolicy_Call struct {
	*mock.Call
}

// SetStackPolicy is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.SetStackPolicyInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) SetStackPolicy(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_SetStackPolicy_Call {
	return &CloudFormation_SetStackPolicy_Call{Call: _e.mock.On("SetStackPolicy",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_SetStackPolicy_Call) Run(run func(ctx context.Context, params *cloudformation.SetStackPolicyInput, optFns ...func(*cloudformation.Options))) *CloudFormation_SetStackPolicy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.SetStackPolicyInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_SetStackPolicy_Call) Return(_a0 *cloudformation.SetStackPolicyOutput, _a1 error) *CloudFormation_SetStackPolicy_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_SetStackPolicy_Call) RunAndReturn(run func(context.Context, *cloudformation.SetStackPolicyInput, ...func(*cloudformation.Options)) (*cloudformation.SetStackPolicyOutput, error)) *CloudFormation_SetStackPolicy_Call {
	_c.Call.Return(run)
	return _c
}

// SetTypeConfiguration provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) SetTypeConfiguration(ctx context.Context, params *cloudformation.SetTypeConfigurationInput, optFns ...func(*cloudformation.Options)) (*cloudformation.SetTypeConfigurationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SetTypeConfiguration")
	}

	var r0 *cloudformation.SetTypeConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetTypeConfigurationInput, ...func(*cloudformation.Options)) (*cloudformation.SetTypeConfigurationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetTypeConfigurationInput, ...func(*cloudformation.Options)) *cloudformation.SetTypeConfigurationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetTypeConfigurationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.SetTypeConfigurationInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_SetTypeConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTypeConfiguration'
type CloudFormation_SetTypeConfiguration_Call struct {
	*mock.Call
}

// SetTypeConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.SetTypeConfigurationInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) SetTypeConfiguration(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_SetTypeConfiguration_Call {
	return &CloudFormation_SetTypeConfiguration_Call{Call: _e.mock.On("SetTypeConfiguration",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_SetTypeConfiguration_Call) Run(run func(ctx context.Context, params *cloudformation.SetTypeConfigurationInput, optFns ...func(*cloudformation.Options))) *CloudFormation_SetTypeConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.SetTypeConfigurationInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_SetTypeConfiguration_Call) Return(_a0 *cloudformation.SetTypeConfigurationOutput, _a1 error) *CloudFormation_SetTypeConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_SetTypeConfiguration_Call) RunAndReturn(run func(context.Context, *cloudformation.SetTypeConfigurationInput, ...func(*cloudformation.Options)) (*cloudformation.SetTypeConfigurationOutput, error)) *CloudFormation_SetTypeConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// SetTypeDefaultVersion provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) SetTypeDefaultVersion(ctx context.Context, params *cloudformation.SetTypeDefaultVersionInput, optFns ...func(*cloudformation.Options)) (*cloudformation.SetTypeDefaultVersionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SetTypeDefaultVersion")
	}

	var r0 *cloudformation.SetTypeDefaultVersionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetTypeDefaultVersionInput, ...func(*cloudformation.Options)) (*cloudformation.SetTypeDefaultVersionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SetTypeDefaultVersionInput, ...func(*cloudformation.Options)) *cloudformation.SetTypeDefaultVersionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SetTypeDefaultVersionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.SetTypeDefaultVersionInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_SetTypeDefaultVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTypeDefaultVersion'
type CloudFormation_SetTypeDefaultVersion_Call struct {
	*mock.Call
}

// SetTypeDefaultVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.SetTypeDefaultVersionInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) SetTypeDefaultVersion(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_SetTypeDefaultVersion_Call {
	return &CloudFormation_SetTypeDefaultVersion_Call{Call: _e.mock.On("SetTypeDefaultVersion",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_SetTypeDefaultVersion_Call) Run(run func(ctx context.Context, params *cloudformation.SetTypeDefaultVersionInput, optFns ...func(*cloudformation.Options))) *CloudFormation_SetTypeDefaultVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.SetTypeDefaultVersionInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_SetTypeDefaultVersion_Call) Return(_a0 *cloudformation.SetTypeDefaultVersionOutput, _a1 error) *CloudFormation_SetTypeDefaultVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_SetTypeDefaultVersion_Call) RunAndReturn(run func(context.Context, *cloudformation.SetTypeDefaultVersionInput, ...func(*cloudformation.Options)) (*cloudformation.SetTypeDefaultVersionOutput, error)) *CloudFormation_SetTypeDefaultVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SignalResource provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) SignalResource(ctx context.Context, params *cloudformation.SignalResourceInput, optFns ...func(*cloudformation.Options)) (*cloudformation.SignalResourceOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SignalResource")
	}

	var r0 *cloudformation.SignalResourceOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SignalResourceInput, ...func(*cloudformation.Options)) (*cloudformation.SignalResourceOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.SignalResourceInput, ...func(*cloudformation.Options)) *cloudformation.SignalResourceOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.SignalResourceOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.SignalResourceInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_SignalResource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignalResource'
type CloudFormation_SignalResource_Call struct {
	*mock.Call
}

// SignalResource is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.SignalResourceInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) SignalResource(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_SignalResource_Call {
	return &CloudFormation_SignalResource_Call{Call: _e.mock.On("SignalResource",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_SignalResource_Call) Run(run func(ctx context.Context, params *cloudformation.SignalResourceInput, optFns ...func(*cloudformation.Options))) *CloudFormation_SignalResource_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.SignalResourceInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_SignalResource_Call) Return(_a0 *cloudformation.SignalResourceOutput, _a1 error) *CloudFormation_SignalResource_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_SignalResource_Call) RunAndReturn(run func(context.Context, *cloudformation.SignalResourceInput, ...func(*cloudformation.Options)) (*cloudformation.SignalResourceOutput, error)) *CloudFormation_SignalResource_Call {
	_c.Call.Return(run)
	return _c
}

// StartResourceScan provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) StartResourceScan(ctx context.Context, params *cloudformation.StartResourceScanInput, optFns ...func(*cloudformation.Options)) (*cloudformation.StartResourceScanOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartResourceScan")
	}

	var r0 *cloudformation.StartResourceScanOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.StartResourceScanInput, ...func(*cloudformation.Options)) (*cloudformation.StartResourceScanOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.StartResourceScanInput, ...func(*cloudformation.Options)) *cloudformation.StartResourceScanOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.StartResourceScanOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.StartResourceScanInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_StartResourceScan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartResourceScan'
type CloudFormation_StartResourceScan_Call struct {
	*mock.Call
}

// StartResourceScan is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.StartResourceScanInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) StartResourceScan(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_StartResourceScan_Call {
	return &CloudFormation_StartResourceScan_Call{Call: _e.mock.On("StartResourceScan",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_StartResourceScan_Call) Run(run func(ctx context.Context, params *cloudformation.StartResourceScanInput, optFns ...func(*cloudformation.Options))) *CloudFormation_StartResourceScan_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.StartResourceScanInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_StartResourceScan_Call) Return(_a0 *cloudformation.StartResourceScanOutput, _a1 error) *CloudFormation_StartResourceScan_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_StartResourceScan_Call) RunAndReturn(run func(context.Context, *cloudformation.StartResourceScanInput, ...func(*cloudformation.Options)) (*cloudformation.StartResourceScanOutput, error)) *CloudFormation_StartResourceScan_Call {
	_c.Call.Return(run)
	return _c
}

// StopStackSetOperation provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) StopStackSetOperation(ctx context.Context, params *cloudformation.StopStackSetOperationInput, optFns ...func(*cloudformation.Options)) (*cloudformation.StopStackSetOperationOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StopStackSetOperation")
	}

	var r0 *cloudformation.StopStackSetOperationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.StopStackSetOperationInput, ...func(*cloudformation.Options)) (*cloudformation.StopStackSetOperationOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.StopStackSetOperationInput, ...func(*cloudformation.Options)) *cloudformation.StopStackSetOperationOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.StopStackSetOperationOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.StopStackSetOperationInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_StopStackSetOperation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopStackSetOperation'
type CloudFormation_StopStackSetOperation_Call struct {
	*mock.Call
}

// StopStackSetOperation is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.StopStackSetOperationInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) StopStackSetOperation(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_StopStackSetOperation_Call {
	return &CloudFormation_StopStackSetOperation_Call{Call: _e.mock.On("StopStackSetOperation",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_StopStackSetOperation_Call) Run(run func(ctx context.Context, params *cloudformation.StopStackSetOperationInput, optFns ...func(*cloudformation.Options))) *CloudFormation_StopStackSetOperation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.StopStackSetOperationInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_StopStackSetOperation_Call) Return(_a0 *cloudformation.StopStackSetOperationOutput, _a1 error) *CloudFormation_StopStackSetOperation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_StopStackSetOperation_Call) RunAndReturn(run func(context.Context, *cloudformation.StopStackSetOperationInput, ...func(*cloudformation.Options)) (*cloudformation.StopStackSetOperationOutput, error)) *CloudFormation_StopStackSetOperation_Call {
	_c.Call.Return(run)
	return _c
}

// TestType provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) TestType(ctx context.Context, params *cloudformation.TestTypeInput, optFns ...func(*cloudformation.Options)) (*cloudformation.TestTypeOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for TestType")
	}

	var r0 *cloudformation.TestTypeOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.TestTypeInput, ...func(*cloudformation.Options)) (*cloudformation.TestTypeOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.TestTypeInput, ...func(*cloudformation.Options)) *cloudformation.TestTypeOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.TestTypeOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.TestTypeInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_TestType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestType'
type CloudFormation_TestType_Call struct {
	*mock.Call
}

// TestType is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.TestTypeInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) TestType(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_TestType_Call {
	return &CloudFormation_TestType_Call{Call: _e.mock.On("TestType",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_TestType_Call) Run(run func(ctx context.Context, params *cloudformation.TestTypeInput, optFns ...func(*cloudformation.Options))) *CloudFormation_TestType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.TestTypeInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_TestType_Call) Return(_a0 *cloudformation.TestTypeOutput, _a1 error) *CloudFormation_TestType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_TestType_Call) RunAndReturn(run func(context.Context, *cloudformation.TestTypeInput, ...func(*cloudformation.Options)) (*cloudformation.TestTypeOutput, error)) *CloudFormation_TestType_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateGeneratedTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) UpdateGeneratedTemplate(ctx context.Context, params *cloudformation.UpdateGeneratedTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.UpdateGeneratedTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateGeneratedTemplate")
	}

	var r0 *cloudformation.UpdateGeneratedTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateGeneratedTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateGeneratedTemplateInput, ...func(*cloudformation.Options)) *cloudformation.UpdateGeneratedTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateGeneratedTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.UpdateGeneratedTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_UpdateGeneratedTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGeneratedTemplate'
type CloudFormation_UpdateGeneratedTemplate_Call struct {
	*mock.Call
}

// UpdateGeneratedTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.UpdateGeneratedTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) UpdateGeneratedTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_UpdateGeneratedTemplate_Call {
	return &CloudFormation_UpdateGeneratedTemplate_Call{Call: _e.mock.On("UpdateGeneratedTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_UpdateGeneratedTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.UpdateGeneratedTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_UpdateGeneratedTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.UpdateGeneratedTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_UpdateGeneratedTemplate_Call) Return(_a0 *cloudformation.UpdateGeneratedTemplateOutput, _a1 error) *CloudFormation_UpdateGeneratedTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_UpdateGeneratedTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.UpdateGeneratedTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateGeneratedTemplateOutput, error)) *CloudFormation_UpdateGeneratedTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStack provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) UpdateStack(ctx context.Context, params *cloudformation.UpdateStackInput, optFns ...func(*cloudformation.Options)) (*cloudformation.UpdateStackOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateStack")
	}

	var r0 *cloudformation.UpdateStackOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackInput, ...func(*cloudformation.Options)) *cloudformation.UpdateStackOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.UpdateStackInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_UpdateStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStack'
type CloudFormation_UpdateStack_Call struct {
	*mock.Call
}

// UpdateStack is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.UpdateStackInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) UpdateStack(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_UpdateStack_Call {
	return &CloudFormation_UpdateStack_Call{Call: _e.mock.On("UpdateStack",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_UpdateStack_Call) Run(run func(ctx context.Context, params *cloudformation.UpdateStackInput, optFns ...func(*cloudformation.Options))) *CloudFormation_UpdateStack_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.UpdateStackInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_UpdateStack_Call) Return(_a0 *cloudformation.UpdateStackOutput, _a1 error) *CloudFormation_UpdateStack_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_UpdateStack_Call) RunAndReturn(run func(context.Context, *cloudformation.UpdateStackInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackOutput, error)) *CloudFormation_UpdateStack_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStackInstances provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) UpdateStackInstances(ctx context.Context, params *cloudformation.UpdateStackInstancesInput, optFns ...func(*cloudformation.Options)) (*cloudformation.UpdateStackInstancesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateStackInstances")
	}

	var r0 *cloudformation.UpdateStackInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackInstancesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackInstancesInput, ...func(*cloudformation.Options)) *cloudformation.UpdateStackInstancesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.UpdateStackInstancesInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_UpdateStackInstances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStackInstances'
type CloudFormation_UpdateStackInstances_Call struct {
	*mock.Call
}

// UpdateStackInstances is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.UpdateStackInstancesInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) UpdateStackInstances(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_UpdateStackInstances_Call {
	return &CloudFormation_UpdateStackInstances_Call{Call: _e.mock.On("UpdateStackInstances",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_UpdateStackInstances_Call) Run(run func(ctx context.Context, params *cloudformation.UpdateStackInstancesInput, optFns ...func(*cloudformation.Options))) *CloudFormation_UpdateStackInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.UpdateStackInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_UpdateStackInstances_Call) Return(_a0 *cloudformation.UpdateStackInstancesOutput, _a1 error) *CloudFormation_UpdateStackInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_UpdateStackInstances_Call) RunAndReturn(run func(context.Context, *cloudformation.UpdateStackInstancesInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackInstancesOutput, error)) *CloudFormation_UpdateStackInstances_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStackSet provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) UpdateStackSet(ctx context.Context, params *cloudformation.UpdateStackSetInput, optFns ...func(*cloudformation.Options)) (*cloudformation.UpdateStackSetOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateStackSet")
	}

	var r0 *cloudformation.UpdateStackSetOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackSetOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateStackSetInput, ...func(*cloudformation.Options)) *cloudformation.UpdateStackSetOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateStackSetOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.UpdateStackSetInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_UpdateStackSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStackSet'
type CloudFormation_UpdateStackSet_Call struct {
	*mock.Call
}

// UpdateStackSet is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.UpdateStackSetInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) UpdateStackSet(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_UpdateStackSet_Call {
	return &CloudFormation_UpdateStackSet_Call{Call: _e.mock.On("UpdateStackSet",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_UpdateStackSet_Call) Run(run func(ctx context.Context, params *cloudformation.UpdateStackSetInput, optFns ...func(*cloudformation.Options))) *CloudFormation_UpdateStackSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.UpdateStackSetInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_UpdateStackSet_Call) Return(_a0 *cloudformation.UpdateStackSetOutput, _a1 error) *CloudFormation_UpdateStackSet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_UpdateStackSet_Call) RunAndReturn(run func(context.Context, *cloudformation.UpdateStackSetInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateStackSetOutput, error)) *CloudFormation_UpdateStackSet_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTerminationProtection provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) UpdateTerminationProtection(ctx context.Context, params *cloudformation.UpdateTerminationProtectionInput, optFns ...func(*cloudformation.Options)) (*cloudformation.UpdateTerminationProtectionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTerminationProtection")
	}

	var r0 *cloudformation.UpdateTerminationProtectionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateTerminationProtectionInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateTerminationProtectionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.UpdateTerminationProtectionInput, ...func(*cloudformation.Options)) *cloudformation.UpdateTerminationProtectionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.UpdateTerminationProtectionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.UpdateTerminationProtectionInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_UpdateTerminationProtection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTerminationProtection'
type CloudFormation_UpdateTerminationProtection_Call struct {
	*mock.Call
}

// UpdateTerminationProtection is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.UpdateTerminationProtectionInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) UpdateTerminationProtection(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_UpdateTerminationProtection_Call {
	return &CloudFormation_UpdateTerminationProtection_Call{Call: _e.mock.On("UpdateTerminationProtection",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_UpdateTerminationProtection_Call) Run(run func(ctx context.Context, params *cloudformation.UpdateTerminationProtectionInput, optFns ...func(*cloudformation.Options))) *CloudFormation_UpdateTerminationProtection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.UpdateTerminationProtectionInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_UpdateTerminationProtection_Call) Return(_a0 *cloudformation.UpdateTerminationProtectionOutput, _a1 error) *CloudFormation_UpdateTerminationProtection_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_UpdateTerminationProtection_Call) RunAndReturn(run func(context.Context, *cloudformation.UpdateTerminationProtectionInput, ...func(*cloudformation.Options)) (*cloudformation.UpdateTerminationProtectionOutput, error)) *CloudFormation_UpdateTerminationProtection_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateTemplate provides a mock function with given fields: ctx, params, optFns
func (_m *CloudFormation) ValidateTemplate(ctx context.Context, params *cloudformation.ValidateTemplateInput, optFns ...func(*cloudformation.Options)) (*cloudformation.ValidateTemplateOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ValidateTemplate")
	}

	var r0 *cloudformation.ValidateTemplateOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ValidateTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.ValidateTemplateOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *cloudformation.ValidateTemplateInput, ...func(*cloudformation.Options)) *cloudformation.ValidateTemplateOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*cloudformation.ValidateTemplateOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *cloudformation.ValidateTemplateInput, ...func(*cloudformation.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudFormation_ValidateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateTemplate'
type CloudFormation_ValidateTemplate_Call struct {
	*mock.Call
}

// ValidateTemplate is a helper method to define mock.On call
//   - ctx context.Context
//   - params *cloudformation.ValidateTemplateInput
//   - optFns ...func(*cloudformation.Options)
func (_e *CloudFormation_Expecter) ValidateTemplate(ctx interface{}, params interface{}, optFns ...interface{}) *CloudFormation_ValidateTemplate_Call {
	return &CloudFormation_ValidateTemplate_Call{Call: _e.mock.On("ValidateTemplate",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *CloudFormation_ValidateTemplate_Call) Run(run func(ctx context.Context, params *cloudformation.ValidateTemplateInput, optFns ...func(*cloudformation.Options))) *CloudFormation_ValidateTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*cloudformation.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*cloudformation.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*cloudformation.ValidateTemplateInput), variadicArgs...)
	})
	return _c
}

func (_c *CloudFormation_ValidateTemplate_Call) Return(_a0 *cloudformation.ValidateTemplateOutput, _a1 error) *CloudFormation_ValidateTemplate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudFormation_ValidateTemplate_Call) RunAndReturn(run func(context.Context, *cloudformation.ValidateTemplateInput, ...func(*cloudformation.Options)) (*cloudformation.ValidateTemplateOutput, error)) *CloudFormation_ValidateTemplate_Call {
	_c.Call.Return(run)
	return _c
}

// NewCloudFormation creates a new instance of CloudFormation. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewCloudFormation(t interface {
	mock.TestingT
	Cleanup(func())
}) *CloudFormation {
	mock := &CloudFormation{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
