CloudFormation.go

// Code generated by mockery v2.38.0. 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// Options provides a mock function with given 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}