diff --git a/.gitignore b/.gitignore
index 89a14aa95..557231103 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,3 @@
 /aws-nuke-*
 /dist
 /releases
-/mocks
diff --git a/mocks/mock_cloudformationiface/mock.go b/mocks/mock_cloudformationiface/mock.go
new file mode 100644
index 000000000..dd6a0fbe6
--- /dev/null
+++ b/mocks/mock_cloudformationiface/mock.go
@@ -0,0 +1,4329 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: /Users/bfisher8/go/pkg/mod/github.com/aws/aws-sdk-go@v1.50.6/service/cloudformation/cloudformationiface/interface.go
+
+// Package mock_cloudformationiface is a generated GoMock package.
+package mock_cloudformationiface
+
+import (
+	reflect "reflect"
+
+	aws "github.com/aws/aws-sdk-go/aws"
+	request "github.com/aws/aws-sdk-go/aws/request"
+	cloudformation "github.com/aws/aws-sdk-go/service/cloudformation"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockCloudFormationAPI is a mock of CloudFormationAPI interface.
+type MockCloudFormationAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockCloudFormationAPIMockRecorder
+}
+
+// MockCloudFormationAPIMockRecorder is the mock recorder for MockCloudFormationAPI.
+type MockCloudFormationAPIMockRecorder struct {
+	mock *MockCloudFormationAPI
+}
+
+// NewMockCloudFormationAPI creates a new mock instance.
+func NewMockCloudFormationAPI(ctrl *gomock.Controller) *MockCloudFormationAPI {
+	mock := &MockCloudFormationAPI{ctrl: ctrl}
+	mock.recorder = &MockCloudFormationAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCloudFormationAPI) EXPECT() *MockCloudFormationAPIMockRecorder {
+	return m.recorder
+}
+
+// ActivateOrganizationsAccess mocks base method.
+func (m *MockCloudFormationAPI) ActivateOrganizationsAccess(arg0 *cloudformation.ActivateOrganizationsAccessInput) (*cloudformation.ActivateOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ActivateOrganizationsAccess", arg0)
+	ret0, _ := ret[0].(*cloudformation.ActivateOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ActivateOrganizationsAccess indicates an expected call of ActivateOrganizationsAccess.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateOrganizationsAccess(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateOrganizationsAccess", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateOrganizationsAccess), arg0)
+}
+
+// ActivateOrganizationsAccessRequest mocks base method.
+func (m *MockCloudFormationAPI) ActivateOrganizationsAccessRequest(arg0 *cloudformation.ActivateOrganizationsAccessInput) (*request.Request, *cloudformation.ActivateOrganizationsAccessOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ActivateOrganizationsAccessRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ActivateOrganizationsAccessOutput)
+	return ret0, ret1
+}
+
+// ActivateOrganizationsAccessRequest indicates an expected call of ActivateOrganizationsAccessRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateOrganizationsAccessRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateOrganizationsAccessRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateOrganizationsAccessRequest), arg0)
+}
+
+// ActivateOrganizationsAccessWithContext mocks base method.
+func (m *MockCloudFormationAPI) ActivateOrganizationsAccessWithContext(arg0 aws.Context, arg1 *cloudformation.ActivateOrganizationsAccessInput, arg2 ...request.Option) (*cloudformation.ActivateOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ActivateOrganizationsAccessWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ActivateOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ActivateOrganizationsAccessWithContext indicates an expected call of ActivateOrganizationsAccessWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateOrganizationsAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateOrganizationsAccessWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateOrganizationsAccessWithContext), varargs...)
+}
+
+// ActivateType mocks base method.
+func (m *MockCloudFormationAPI) ActivateType(arg0 *cloudformation.ActivateTypeInput) (*cloudformation.ActivateTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ActivateType", arg0)
+	ret0, _ := ret[0].(*cloudformation.ActivateTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ActivateType indicates an expected call of ActivateType.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateType", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateType), arg0)
+}
+
+// ActivateTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) ActivateTypeRequest(arg0 *cloudformation.ActivateTypeInput) (*request.Request, *cloudformation.ActivateTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ActivateTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ActivateTypeOutput)
+	return ret0, ret1
+}
+
+// ActivateTypeRequest indicates an expected call of ActivateTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateTypeRequest), arg0)
+}
+
+// ActivateTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) ActivateTypeWithContext(arg0 aws.Context, arg1 *cloudformation.ActivateTypeInput, arg2 ...request.Option) (*cloudformation.ActivateTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ActivateTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ActivateTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ActivateTypeWithContext indicates an expected call of ActivateTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ActivateTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ActivateTypeWithContext), varargs...)
+}
+
+// BatchDescribeTypeConfigurations mocks base method.
+func (m *MockCloudFormationAPI) BatchDescribeTypeConfigurations(arg0 *cloudformation.BatchDescribeTypeConfigurationsInput) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchDescribeTypeConfigurations", arg0)
+	ret0, _ := ret[0].(*cloudformation.BatchDescribeTypeConfigurationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchDescribeTypeConfigurations indicates an expected call of BatchDescribeTypeConfigurations.
+func (mr *MockCloudFormationAPIMockRecorder) BatchDescribeTypeConfigurations(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDescribeTypeConfigurations", reflect.TypeOf((*MockCloudFormationAPI)(nil).BatchDescribeTypeConfigurations), arg0)
+}
+
+// BatchDescribeTypeConfigurationsRequest mocks base method.
+func (m *MockCloudFormationAPI) BatchDescribeTypeConfigurationsRequest(arg0 *cloudformation.BatchDescribeTypeConfigurationsInput) (*request.Request, *cloudformation.BatchDescribeTypeConfigurationsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchDescribeTypeConfigurationsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.BatchDescribeTypeConfigurationsOutput)
+	return ret0, ret1
+}
+
+// BatchDescribeTypeConfigurationsRequest indicates an expected call of BatchDescribeTypeConfigurationsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) BatchDescribeTypeConfigurationsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDescribeTypeConfigurationsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).BatchDescribeTypeConfigurationsRequest), arg0)
+}
+
+// BatchDescribeTypeConfigurationsWithContext mocks base method.
+func (m *MockCloudFormationAPI) BatchDescribeTypeConfigurationsWithContext(arg0 aws.Context, arg1 *cloudformation.BatchDescribeTypeConfigurationsInput, arg2 ...request.Option) (*cloudformation.BatchDescribeTypeConfigurationsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BatchDescribeTypeConfigurationsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.BatchDescribeTypeConfigurationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchDescribeTypeConfigurationsWithContext indicates an expected call of BatchDescribeTypeConfigurationsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) BatchDescribeTypeConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDescribeTypeConfigurationsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).BatchDescribeTypeConfigurationsWithContext), varargs...)
+}
+
+// CancelUpdateStack mocks base method.
+func (m *MockCloudFormationAPI) CancelUpdateStack(arg0 *cloudformation.CancelUpdateStackInput) (*cloudformation.CancelUpdateStackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CancelUpdateStack", arg0)
+	ret0, _ := ret[0].(*cloudformation.CancelUpdateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CancelUpdateStack indicates an expected call of CancelUpdateStack.
+func (mr *MockCloudFormationAPIMockRecorder) CancelUpdateStack(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelUpdateStack", reflect.TypeOf((*MockCloudFormationAPI)(nil).CancelUpdateStack), arg0)
+}
+
+// CancelUpdateStackRequest mocks base method.
+func (m *MockCloudFormationAPI) CancelUpdateStackRequest(arg0 *cloudformation.CancelUpdateStackInput) (*request.Request, *cloudformation.CancelUpdateStackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CancelUpdateStackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CancelUpdateStackOutput)
+	return ret0, ret1
+}
+
+// CancelUpdateStackRequest indicates an expected call of CancelUpdateStackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CancelUpdateStackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelUpdateStackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CancelUpdateStackRequest), arg0)
+}
+
+// CancelUpdateStackWithContext mocks base method.
+func (m *MockCloudFormationAPI) CancelUpdateStackWithContext(arg0 aws.Context, arg1 *cloudformation.CancelUpdateStackInput, arg2 ...request.Option) (*cloudformation.CancelUpdateStackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CancelUpdateStackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CancelUpdateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CancelUpdateStackWithContext indicates an expected call of CancelUpdateStackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CancelUpdateStackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelUpdateStackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CancelUpdateStackWithContext), varargs...)
+}
+
+// ContinueUpdateRollback mocks base method.
+func (m *MockCloudFormationAPI) ContinueUpdateRollback(arg0 *cloudformation.ContinueUpdateRollbackInput) (*cloudformation.ContinueUpdateRollbackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContinueUpdateRollback", arg0)
+	ret0, _ := ret[0].(*cloudformation.ContinueUpdateRollbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContinueUpdateRollback indicates an expected call of ContinueUpdateRollback.
+func (mr *MockCloudFormationAPIMockRecorder) ContinueUpdateRollback(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContinueUpdateRollback", reflect.TypeOf((*MockCloudFormationAPI)(nil).ContinueUpdateRollback), arg0)
+}
+
+// ContinueUpdateRollbackRequest mocks base method.
+func (m *MockCloudFormationAPI) ContinueUpdateRollbackRequest(arg0 *cloudformation.ContinueUpdateRollbackInput) (*request.Request, *cloudformation.ContinueUpdateRollbackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContinueUpdateRollbackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ContinueUpdateRollbackOutput)
+	return ret0, ret1
+}
+
+// ContinueUpdateRollbackRequest indicates an expected call of ContinueUpdateRollbackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ContinueUpdateRollbackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContinueUpdateRollbackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ContinueUpdateRollbackRequest), arg0)
+}
+
+// ContinueUpdateRollbackWithContext mocks base method.
+func (m *MockCloudFormationAPI) ContinueUpdateRollbackWithContext(arg0 aws.Context, arg1 *cloudformation.ContinueUpdateRollbackInput, arg2 ...request.Option) (*cloudformation.ContinueUpdateRollbackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ContinueUpdateRollbackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ContinueUpdateRollbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContinueUpdateRollbackWithContext indicates an expected call of ContinueUpdateRollbackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ContinueUpdateRollbackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContinueUpdateRollbackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ContinueUpdateRollbackWithContext), varargs...)
+}
+
+// CreateChangeSet mocks base method.
+func (m *MockCloudFormationAPI) CreateChangeSet(arg0 *cloudformation.CreateChangeSetInput) (*cloudformation.CreateChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateChangeSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.CreateChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateChangeSet indicates an expected call of CreateChangeSet.
+func (mr *MockCloudFormationAPIMockRecorder) CreateChangeSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangeSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateChangeSet), arg0)
+}
+
+// CreateChangeSetRequest mocks base method.
+func (m *MockCloudFormationAPI) CreateChangeSetRequest(arg0 *cloudformation.CreateChangeSetInput) (*request.Request, *cloudformation.CreateChangeSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateChangeSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CreateChangeSetOutput)
+	return ret0, ret1
+}
+
+// CreateChangeSetRequest indicates an expected call of CreateChangeSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CreateChangeSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangeSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateChangeSetRequest), arg0)
+}
+
+// CreateChangeSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) CreateChangeSetWithContext(arg0 aws.Context, arg1 *cloudformation.CreateChangeSetInput, arg2 ...request.Option) (*cloudformation.CreateChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateChangeSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CreateChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateChangeSetWithContext indicates an expected call of CreateChangeSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CreateChangeSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateChangeSetWithContext), varargs...)
+}
+
+// CreateStack mocks base method.
+func (m *MockCloudFormationAPI) CreateStack(arg0 *cloudformation.CreateStackInput) (*cloudformation.CreateStackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStack", arg0)
+	ret0, _ := ret[0].(*cloudformation.CreateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStack indicates an expected call of CreateStack.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStack(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStack", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStack), arg0)
+}
+
+// CreateStackInstances mocks base method.
+func (m *MockCloudFormationAPI) CreateStackInstances(arg0 *cloudformation.CreateStackInstancesInput) (*cloudformation.CreateStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStackInstances", arg0)
+	ret0, _ := ret[0].(*cloudformation.CreateStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStackInstances indicates an expected call of CreateStackInstances.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackInstances(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackInstances", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackInstances), arg0)
+}
+
+// CreateStackInstancesRequest mocks base method.
+func (m *MockCloudFormationAPI) CreateStackInstancesRequest(arg0 *cloudformation.CreateStackInstancesInput) (*request.Request, *cloudformation.CreateStackInstancesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStackInstancesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CreateStackInstancesOutput)
+	return ret0, ret1
+}
+
+// CreateStackInstancesRequest indicates an expected call of CreateStackInstancesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackInstancesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackInstancesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackInstancesRequest), arg0)
+}
+
+// CreateStackInstancesWithContext mocks base method.
+func (m *MockCloudFormationAPI) CreateStackInstancesWithContext(arg0 aws.Context, arg1 *cloudformation.CreateStackInstancesInput, arg2 ...request.Option) (*cloudformation.CreateStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateStackInstancesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CreateStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStackInstancesWithContext indicates an expected call of CreateStackInstancesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackInstancesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackInstancesWithContext), varargs...)
+}
+
+// CreateStackRequest mocks base method.
+func (m *MockCloudFormationAPI) CreateStackRequest(arg0 *cloudformation.CreateStackInput) (*request.Request, *cloudformation.CreateStackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CreateStackOutput)
+	return ret0, ret1
+}
+
+// CreateStackRequest indicates an expected call of CreateStackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackRequest), arg0)
+}
+
+// CreateStackSet mocks base method.
+func (m *MockCloudFormationAPI) CreateStackSet(arg0 *cloudformation.CreateStackSetInput) (*cloudformation.CreateStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStackSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.CreateStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStackSet indicates an expected call of CreateStackSet.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackSet), arg0)
+}
+
+// CreateStackSetRequest mocks base method.
+func (m *MockCloudFormationAPI) CreateStackSetRequest(arg0 *cloudformation.CreateStackSetInput) (*request.Request, *cloudformation.CreateStackSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStackSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CreateStackSetOutput)
+	return ret0, ret1
+}
+
+// CreateStackSetRequest indicates an expected call of CreateStackSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackSetRequest), arg0)
+}
+
+// CreateStackSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) CreateStackSetWithContext(arg0 aws.Context, arg1 *cloudformation.CreateStackSetInput, arg2 ...request.Option) (*cloudformation.CreateStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateStackSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CreateStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStackSetWithContext indicates an expected call of CreateStackSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackSetWithContext), varargs...)
+}
+
+// CreateStackWithContext mocks base method.
+func (m *MockCloudFormationAPI) CreateStackWithContext(arg0 aws.Context, arg1 *cloudformation.CreateStackInput, arg2 ...request.Option) (*cloudformation.CreateStackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateStackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CreateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStackWithContext indicates an expected call of CreateStackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CreateStackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateStackWithContext), varargs...)
+}
+
+// DeactivateOrganizationsAccess mocks base method.
+func (m *MockCloudFormationAPI) DeactivateOrganizationsAccess(arg0 *cloudformation.DeactivateOrganizationsAccessInput) (*cloudformation.DeactivateOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeactivateOrganizationsAccess", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeactivateOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeactivateOrganizationsAccess indicates an expected call of DeactivateOrganizationsAccess.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateOrganizationsAccess(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateOrganizationsAccess", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateOrganizationsAccess), arg0)
+}
+
+// DeactivateOrganizationsAccessRequest mocks base method.
+func (m *MockCloudFormationAPI) DeactivateOrganizationsAccessRequest(arg0 *cloudformation.DeactivateOrganizationsAccessInput) (*request.Request, *cloudformation.DeactivateOrganizationsAccessOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeactivateOrganizationsAccessRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeactivateOrganizationsAccessOutput)
+	return ret0, ret1
+}
+
+// DeactivateOrganizationsAccessRequest indicates an expected call of DeactivateOrganizationsAccessRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateOrganizationsAccessRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateOrganizationsAccessRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateOrganizationsAccessRequest), arg0)
+}
+
+// DeactivateOrganizationsAccessWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeactivateOrganizationsAccessWithContext(arg0 aws.Context, arg1 *cloudformation.DeactivateOrganizationsAccessInput, arg2 ...request.Option) (*cloudformation.DeactivateOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeactivateOrganizationsAccessWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeactivateOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeactivateOrganizationsAccessWithContext indicates an expected call of DeactivateOrganizationsAccessWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateOrganizationsAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateOrganizationsAccessWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateOrganizationsAccessWithContext), varargs...)
+}
+
+// DeactivateType mocks base method.
+func (m *MockCloudFormationAPI) DeactivateType(arg0 *cloudformation.DeactivateTypeInput) (*cloudformation.DeactivateTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeactivateType", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeactivateTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeactivateType indicates an expected call of DeactivateType.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateType", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateType), arg0)
+}
+
+// DeactivateTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) DeactivateTypeRequest(arg0 *cloudformation.DeactivateTypeInput) (*request.Request, *cloudformation.DeactivateTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeactivateTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeactivateTypeOutput)
+	return ret0, ret1
+}
+
+// DeactivateTypeRequest indicates an expected call of DeactivateTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateTypeRequest), arg0)
+}
+
+// DeactivateTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeactivateTypeWithContext(arg0 aws.Context, arg1 *cloudformation.DeactivateTypeInput, arg2 ...request.Option) (*cloudformation.DeactivateTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeactivateTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeactivateTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeactivateTypeWithContext indicates an expected call of DeactivateTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeactivateTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeactivateTypeWithContext), varargs...)
+}
+
+// DeleteChangeSet mocks base method.
+func (m *MockCloudFormationAPI) DeleteChangeSet(arg0 *cloudformation.DeleteChangeSetInput) (*cloudformation.DeleteChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteChangeSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeleteChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteChangeSet indicates an expected call of DeleteChangeSet.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteChangeSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangeSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteChangeSet), arg0)
+}
+
+// DeleteChangeSetRequest mocks base method.
+func (m *MockCloudFormationAPI) DeleteChangeSetRequest(arg0 *cloudformation.DeleteChangeSetInput) (*request.Request, *cloudformation.DeleteChangeSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteChangeSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeleteChangeSetOutput)
+	return ret0, ret1
+}
+
+// DeleteChangeSetRequest indicates an expected call of DeleteChangeSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteChangeSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangeSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteChangeSetRequest), arg0)
+}
+
+// DeleteChangeSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeleteChangeSetWithContext(arg0 aws.Context, arg1 *cloudformation.DeleteChangeSetInput, arg2 ...request.Option) (*cloudformation.DeleteChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteChangeSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeleteChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteChangeSetWithContext indicates an expected call of DeleteChangeSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteChangeSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteChangeSetWithContext), varargs...)
+}
+
+// DeleteStack mocks base method.
+func (m *MockCloudFormationAPI) DeleteStack(arg0 *cloudformation.DeleteStackInput) (*cloudformation.DeleteStackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStack", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStack indicates an expected call of DeleteStack.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStack(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStack", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStack), arg0)
+}
+
+// DeleteStackInstances mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackInstances(arg0 *cloudformation.DeleteStackInstancesInput) (*cloudformation.DeleteStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStackInstances", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStackInstances indicates an expected call of DeleteStackInstances.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackInstances(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackInstances", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackInstances), arg0)
+}
+
+// DeleteStackInstancesRequest mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackInstancesRequest(arg0 *cloudformation.DeleteStackInstancesInput) (*request.Request, *cloudformation.DeleteStackInstancesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStackInstancesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeleteStackInstancesOutput)
+	return ret0, ret1
+}
+
+// DeleteStackInstancesRequest indicates an expected call of DeleteStackInstancesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackInstancesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackInstancesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackInstancesRequest), arg0)
+}
+
+// DeleteStackInstancesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackInstancesWithContext(arg0 aws.Context, arg1 *cloudformation.DeleteStackInstancesInput, arg2 ...request.Option) (*cloudformation.DeleteStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteStackInstancesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStackInstancesWithContext indicates an expected call of DeleteStackInstancesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackInstancesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackInstancesWithContext), varargs...)
+}
+
+// DeleteStackRequest mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackRequest(arg0 *cloudformation.DeleteStackInput) (*request.Request, *cloudformation.DeleteStackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeleteStackOutput)
+	return ret0, ret1
+}
+
+// DeleteStackRequest indicates an expected call of DeleteStackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackRequest), arg0)
+}
+
+// DeleteStackSet mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackSet(arg0 *cloudformation.DeleteStackSetInput) (*cloudformation.DeleteStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStackSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStackSet indicates an expected call of DeleteStackSet.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackSet), arg0)
+}
+
+// DeleteStackSetRequest mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackSetRequest(arg0 *cloudformation.DeleteStackSetInput) (*request.Request, *cloudformation.DeleteStackSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStackSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeleteStackSetOutput)
+	return ret0, ret1
+}
+
+// DeleteStackSetRequest indicates an expected call of DeleteStackSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackSetRequest), arg0)
+}
+
+// DeleteStackSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackSetWithContext(arg0 aws.Context, arg1 *cloudformation.DeleteStackSetInput, arg2 ...request.Option) (*cloudformation.DeleteStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteStackSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStackSetWithContext indicates an expected call of DeleteStackSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackSetWithContext), varargs...)
+}
+
+// DeleteStackWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeleteStackWithContext(arg0 aws.Context, arg1 *cloudformation.DeleteStackInput, arg2 ...request.Option) (*cloudformation.DeleteStackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteStackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeleteStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteStackWithContext indicates an expected call of DeleteStackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteStackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteStackWithContext), varargs...)
+}
+
+// DeregisterType mocks base method.
+func (m *MockCloudFormationAPI) DeregisterType(arg0 *cloudformation.DeregisterTypeInput) (*cloudformation.DeregisterTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeregisterType", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeregisterTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeregisterType indicates an expected call of DeregisterType.
+func (mr *MockCloudFormationAPIMockRecorder) DeregisterType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterType", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeregisterType), arg0)
+}
+
+// DeregisterTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) DeregisterTypeRequest(arg0 *cloudformation.DeregisterTypeInput) (*request.Request, *cloudformation.DeregisterTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeregisterTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeregisterTypeOutput)
+	return ret0, ret1
+}
+
+// DeregisterTypeRequest indicates an expected call of DeregisterTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeregisterTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeregisterTypeRequest), arg0)
+}
+
+// DeregisterTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeregisterTypeWithContext(arg0 aws.Context, arg1 *cloudformation.DeregisterTypeInput, arg2 ...request.Option) (*cloudformation.DeregisterTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeregisterTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeregisterTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeregisterTypeWithContext indicates an expected call of DeregisterTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeregisterTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeregisterTypeWithContext), varargs...)
+}
+
+// DescribeAccountLimits mocks base method.
+func (m *MockCloudFormationAPI) DescribeAccountLimits(arg0 *cloudformation.DescribeAccountLimitsInput) (*cloudformation.DescribeAccountLimitsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeAccountLimitsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeAccountLimits indicates an expected call of DescribeAccountLimits.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeAccountLimits), arg0)
+}
+
+// DescribeAccountLimitsPages mocks base method.
+func (m *MockCloudFormationAPI) DescribeAccountLimitsPages(arg0 *cloudformation.DescribeAccountLimitsInput, arg1 func(*cloudformation.DescribeAccountLimitsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeAccountLimitsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeAccountLimitsPages indicates an expected call of DescribeAccountLimitsPages.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeAccountLimitsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeAccountLimitsPages), arg0, arg1)
+}
+
+// DescribeAccountLimitsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeAccountLimitsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeAccountLimitsInput, arg2 func(*cloudformation.DescribeAccountLimitsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeAccountLimitsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeAccountLimitsPagesWithContext indicates an expected call of DescribeAccountLimitsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeAccountLimitsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeAccountLimitsPagesWithContext), varargs...)
+}
+
+// DescribeAccountLimitsRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeAccountLimitsRequest(arg0 *cloudformation.DescribeAccountLimitsInput) (*request.Request, *cloudformation.DescribeAccountLimitsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeAccountLimitsOutput)
+	return ret0, ret1
+}
+
+// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeAccountLimitsRequest), arg0)
+}
+
+// DescribeAccountLimitsWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeAccountLimitsInput, arg2 ...request.Option) (*cloudformation.DescribeAccountLimitsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeAccountLimitsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeAccountLimitsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeAccountLimitsWithContext), varargs...)
+}
+
+// DescribeChangeSet mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSet(arg0 *cloudformation.DescribeChangeSetInput) (*cloudformation.DescribeChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeChangeSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeChangeSet indicates an expected call of DescribeChangeSet.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSet), arg0)
+}
+
+// DescribeChangeSetHooks mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSetHooks(arg0 *cloudformation.DescribeChangeSetHooksInput) (*cloudformation.DescribeChangeSetHooksOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeChangeSetHooks", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeChangeSetHooksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeChangeSetHooks indicates an expected call of DescribeChangeSetHooks.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetHooks(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetHooks", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetHooks), arg0)
+}
+
+// DescribeChangeSetHooksRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSetHooksRequest(arg0 *cloudformation.DescribeChangeSetHooksInput) (*request.Request, *cloudformation.DescribeChangeSetHooksOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeChangeSetHooksRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeChangeSetHooksOutput)
+	return ret0, ret1
+}
+
+// DescribeChangeSetHooksRequest indicates an expected call of DescribeChangeSetHooksRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetHooksRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetHooksRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetHooksRequest), arg0)
+}
+
+// DescribeChangeSetHooksWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSetHooksWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeChangeSetHooksInput, arg2 ...request.Option) (*cloudformation.DescribeChangeSetHooksOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeChangeSetHooksWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeChangeSetHooksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeChangeSetHooksWithContext indicates an expected call of DescribeChangeSetHooksWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetHooksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetHooksWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetHooksWithContext), varargs...)
+}
+
+// DescribeChangeSetRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSetRequest(arg0 *cloudformation.DescribeChangeSetInput) (*request.Request, *cloudformation.DescribeChangeSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeChangeSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeChangeSetOutput)
+	return ret0, ret1
+}
+
+// DescribeChangeSetRequest indicates an expected call of DescribeChangeSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetRequest), arg0)
+}
+
+// DescribeChangeSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeChangeSetWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeChangeSetInput, arg2 ...request.Option) (*cloudformation.DescribeChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeChangeSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeChangeSetWithContext indicates an expected call of DescribeChangeSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetWithContext), varargs...)
+}
+
+// DescribeOrganizationsAccess mocks base method.
+func (m *MockCloudFormationAPI) DescribeOrganizationsAccess(arg0 *cloudformation.DescribeOrganizationsAccessInput) (*cloudformation.DescribeOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeOrganizationsAccess", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeOrganizationsAccess indicates an expected call of DescribeOrganizationsAccess.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeOrganizationsAccess(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationsAccess", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeOrganizationsAccess), arg0)
+}
+
+// DescribeOrganizationsAccessRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeOrganizationsAccessRequest(arg0 *cloudformation.DescribeOrganizationsAccessInput) (*request.Request, *cloudformation.DescribeOrganizationsAccessOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeOrganizationsAccessRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeOrganizationsAccessOutput)
+	return ret0, ret1
+}
+
+// DescribeOrganizationsAccessRequest indicates an expected call of DescribeOrganizationsAccessRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeOrganizationsAccessRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationsAccessRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeOrganizationsAccessRequest), arg0)
+}
+
+// DescribeOrganizationsAccessWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeOrganizationsAccessWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeOrganizationsAccessInput, arg2 ...request.Option) (*cloudformation.DescribeOrganizationsAccessOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeOrganizationsAccessWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeOrganizationsAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeOrganizationsAccessWithContext indicates an expected call of DescribeOrganizationsAccessWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeOrganizationsAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationsAccessWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeOrganizationsAccessWithContext), varargs...)
+}
+
+// DescribePublisher mocks base method.
+func (m *MockCloudFormationAPI) DescribePublisher(arg0 *cloudformation.DescribePublisherInput) (*cloudformation.DescribePublisherOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribePublisher", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribePublisherOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribePublisher indicates an expected call of DescribePublisher.
+func (mr *MockCloudFormationAPIMockRecorder) DescribePublisher(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublisher", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribePublisher), arg0)
+}
+
+// DescribePublisherRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribePublisherRequest(arg0 *cloudformation.DescribePublisherInput) (*request.Request, *cloudformation.DescribePublisherOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribePublisherRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribePublisherOutput)
+	return ret0, ret1
+}
+
+// DescribePublisherRequest indicates an expected call of DescribePublisherRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribePublisherRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublisherRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribePublisherRequest), arg0)
+}
+
+// DescribePublisherWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribePublisherWithContext(arg0 aws.Context, arg1 *cloudformation.DescribePublisherInput, arg2 ...request.Option) (*cloudformation.DescribePublisherOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribePublisherWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribePublisherOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribePublisherWithContext indicates an expected call of DescribePublisherWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribePublisherWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublisherWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribePublisherWithContext), varargs...)
+}
+
+// DescribeStackDriftDetectionStatus mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackDriftDetectionStatus(arg0 *cloudformation.DescribeStackDriftDetectionStatusInput) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackDriftDetectionStatus", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackDriftDetectionStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackDriftDetectionStatus indicates an expected call of DescribeStackDriftDetectionStatus.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackDriftDetectionStatus(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackDriftDetectionStatus", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackDriftDetectionStatus), arg0)
+}
+
+// DescribeStackDriftDetectionStatusRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackDriftDetectionStatusRequest(arg0 *cloudformation.DescribeStackDriftDetectionStatusInput) (*request.Request, *cloudformation.DescribeStackDriftDetectionStatusOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackDriftDetectionStatusRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackDriftDetectionStatusOutput)
+	return ret0, ret1
+}
+
+// DescribeStackDriftDetectionStatusRequest indicates an expected call of DescribeStackDriftDetectionStatusRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackDriftDetectionStatusRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackDriftDetectionStatusRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackDriftDetectionStatusRequest), arg0)
+}
+
+// DescribeStackDriftDetectionStatusWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackDriftDetectionStatusWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackDriftDetectionStatusInput, arg2 ...request.Option) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackDriftDetectionStatusWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackDriftDetectionStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackDriftDetectionStatusWithContext indicates an expected call of DescribeStackDriftDetectionStatusWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackDriftDetectionStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackDriftDetectionStatusWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackDriftDetectionStatusWithContext), varargs...)
+}
+
+// DescribeStackEvents mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackEvents(arg0 *cloudformation.DescribeStackEventsInput) (*cloudformation.DescribeStackEventsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackEvents", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackEventsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackEvents indicates an expected call of DescribeStackEvents.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackEvents(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackEvents", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackEvents), arg0)
+}
+
+// DescribeStackEventsPages mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackEventsPages(arg0 *cloudformation.DescribeStackEventsInput, arg1 func(*cloudformation.DescribeStackEventsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackEventsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStackEventsPages indicates an expected call of DescribeStackEventsPages.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackEventsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackEventsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackEventsPages), arg0, arg1)
+}
+
+// DescribeStackEventsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackEventsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackEventsInput, arg2 func(*cloudformation.DescribeStackEventsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackEventsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStackEventsPagesWithContext indicates an expected call of DescribeStackEventsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackEventsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackEventsPagesWithContext), varargs...)
+}
+
+// DescribeStackEventsRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackEventsRequest(arg0 *cloudformation.DescribeStackEventsInput) (*request.Request, *cloudformation.DescribeStackEventsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackEventsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackEventsOutput)
+	return ret0, ret1
+}
+
+// DescribeStackEventsRequest indicates an expected call of DescribeStackEventsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackEventsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackEventsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackEventsRequest), arg0)
+}
+
+// DescribeStackEventsWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackEventsWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackEventsInput, arg2 ...request.Option) (*cloudformation.DescribeStackEventsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackEventsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackEventsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackEventsWithContext indicates an expected call of DescribeStackEventsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackEventsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackEventsWithContext), varargs...)
+}
+
+// DescribeStackInstance mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackInstance(arg0 *cloudformation.DescribeStackInstanceInput) (*cloudformation.DescribeStackInstanceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackInstance", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackInstanceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackInstance indicates an expected call of DescribeStackInstance.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackInstance(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackInstance", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackInstance), arg0)
+}
+
+// DescribeStackInstanceRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackInstanceRequest(arg0 *cloudformation.DescribeStackInstanceInput) (*request.Request, *cloudformation.DescribeStackInstanceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackInstanceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackInstanceOutput)
+	return ret0, ret1
+}
+
+// DescribeStackInstanceRequest indicates an expected call of DescribeStackInstanceRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackInstanceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackInstanceRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackInstanceRequest), arg0)
+}
+
+// DescribeStackInstanceWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackInstanceWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackInstanceInput, arg2 ...request.Option) (*cloudformation.DescribeStackInstanceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackInstanceWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackInstanceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackInstanceWithContext indicates an expected call of DescribeStackInstanceWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackInstanceWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackInstanceWithContext), varargs...)
+}
+
+// DescribeStackResource mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResource(arg0 *cloudformation.DescribeStackResourceInput) (*cloudformation.DescribeStackResourceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResource", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResource indicates an expected call of DescribeStackResource.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResource(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResource", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResource), arg0)
+}
+
+// DescribeStackResourceDrifts mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceDrifts(arg0 *cloudformation.DescribeStackResourceDriftsInput) (*cloudformation.DescribeStackResourceDriftsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResourceDrifts", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourceDriftsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResourceDrifts indicates an expected call of DescribeStackResourceDrifts.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceDrifts(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceDrifts", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceDrifts), arg0)
+}
+
+// DescribeStackResourceDriftsPages mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceDriftsPages(arg0 *cloudformation.DescribeStackResourceDriftsInput, arg1 func(*cloudformation.DescribeStackResourceDriftsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResourceDriftsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStackResourceDriftsPages indicates an expected call of DescribeStackResourceDriftsPages.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceDriftsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceDriftsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceDriftsPages), arg0, arg1)
+}
+
+// DescribeStackResourceDriftsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceDriftsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackResourceDriftsInput, arg2 func(*cloudformation.DescribeStackResourceDriftsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackResourceDriftsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStackResourceDriftsPagesWithContext indicates an expected call of DescribeStackResourceDriftsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceDriftsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceDriftsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceDriftsPagesWithContext), varargs...)
+}
+
+// DescribeStackResourceDriftsRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceDriftsRequest(arg0 *cloudformation.DescribeStackResourceDriftsInput) (*request.Request, *cloudformation.DescribeStackResourceDriftsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResourceDriftsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackResourceDriftsOutput)
+	return ret0, ret1
+}
+
+// DescribeStackResourceDriftsRequest indicates an expected call of DescribeStackResourceDriftsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceDriftsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceDriftsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceDriftsRequest), arg0)
+}
+
+// DescribeStackResourceDriftsWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceDriftsWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackResourceDriftsInput, arg2 ...request.Option) (*cloudformation.DescribeStackResourceDriftsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackResourceDriftsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourceDriftsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResourceDriftsWithContext indicates an expected call of DescribeStackResourceDriftsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceDriftsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceDriftsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceDriftsWithContext), varargs...)
+}
+
+// DescribeStackResourceRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceRequest(arg0 *cloudformation.DescribeStackResourceInput) (*request.Request, *cloudformation.DescribeStackResourceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResourceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackResourceOutput)
+	return ret0, ret1
+}
+
+// DescribeStackResourceRequest indicates an expected call of DescribeStackResourceRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceRequest), arg0)
+}
+
+// DescribeStackResourceWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourceWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackResourceInput, arg2 ...request.Option) (*cloudformation.DescribeStackResourceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackResourceWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResourceWithContext indicates an expected call of DescribeStackResourceWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourceWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourceWithContext), varargs...)
+}
+
+// DescribeStackResources mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResources(arg0 *cloudformation.DescribeStackResourcesInput) (*cloudformation.DescribeStackResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResources", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResources indicates an expected call of DescribeStackResources.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResources(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResources", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResources), arg0)
+}
+
+// DescribeStackResourcesRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourcesRequest(arg0 *cloudformation.DescribeStackResourcesInput) (*request.Request, *cloudformation.DescribeStackResourcesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackResourcesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackResourcesOutput)
+	return ret0, ret1
+}
+
+// DescribeStackResourcesRequest indicates an expected call of DescribeStackResourcesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourcesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourcesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourcesRequest), arg0)
+}
+
+// DescribeStackResourcesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackResourcesWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackResourcesInput, arg2 ...request.Option) (*cloudformation.DescribeStackResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackResourcesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackResourcesWithContext indicates an expected call of DescribeStackResourcesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackResourcesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackResourcesWithContext), varargs...)
+}
+
+// DescribeStackSet mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSet(arg0 *cloudformation.DescribeStackSetInput) (*cloudformation.DescribeStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackSet indicates an expected call of DescribeStackSet.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSet), arg0)
+}
+
+// DescribeStackSetOperation mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSetOperation(arg0 *cloudformation.DescribeStackSetOperationInput) (*cloudformation.DescribeStackSetOperationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackSetOperation", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackSetOperationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackSetOperation indicates an expected call of DescribeStackSetOperation.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSetOperation(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSetOperation", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSetOperation), arg0)
+}
+
+// DescribeStackSetOperationRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSetOperationRequest(arg0 *cloudformation.DescribeStackSetOperationInput) (*request.Request, *cloudformation.DescribeStackSetOperationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackSetOperationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackSetOperationOutput)
+	return ret0, ret1
+}
+
+// DescribeStackSetOperationRequest indicates an expected call of DescribeStackSetOperationRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSetOperationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSetOperationRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSetOperationRequest), arg0)
+}
+
+// DescribeStackSetOperationWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSetOperationWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackSetOperationInput, arg2 ...request.Option) (*cloudformation.DescribeStackSetOperationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackSetOperationWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackSetOperationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackSetOperationWithContext indicates an expected call of DescribeStackSetOperationWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSetOperationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSetOperationWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSetOperationWithContext), varargs...)
+}
+
+// DescribeStackSetRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSetRequest(arg0 *cloudformation.DescribeStackSetInput) (*request.Request, *cloudformation.DescribeStackSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStackSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStackSetOutput)
+	return ret0, ret1
+}
+
+// DescribeStackSetRequest indicates an expected call of DescribeStackSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSetRequest), arg0)
+}
+
+// DescribeStackSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStackSetWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStackSetInput, arg2 ...request.Option) (*cloudformation.DescribeStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStackSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStackSetWithContext indicates an expected call of DescribeStackSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStackSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStackSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStackSetWithContext), varargs...)
+}
+
+// DescribeStacks mocks base method.
+func (m *MockCloudFormationAPI) DescribeStacks(arg0 *cloudformation.DescribeStacksInput) (*cloudformation.DescribeStacksOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStacks", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeStacksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStacks indicates an expected call of DescribeStacks.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStacks(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStacks", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStacks), arg0)
+}
+
+// DescribeStacksPages mocks base method.
+func (m *MockCloudFormationAPI) DescribeStacksPages(arg0 *cloudformation.DescribeStacksInput, arg1 func(*cloudformation.DescribeStacksOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStacksPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStacksPages indicates an expected call of DescribeStacksPages.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStacksPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStacksPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStacksPages), arg0, arg1)
+}
+
+// DescribeStacksPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStacksPagesWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 func(*cloudformation.DescribeStacksOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStacksPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeStacksPagesWithContext indicates an expected call of DescribeStacksPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStacksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStacksPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStacksPagesWithContext), varargs...)
+}
+
+// DescribeStacksRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeStacksRequest(arg0 *cloudformation.DescribeStacksInput) (*request.Request, *cloudformation.DescribeStacksOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeStacksRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeStacksOutput)
+	return ret0, ret1
+}
+
+// DescribeStacksRequest indicates an expected call of DescribeStacksRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStacksRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStacksRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStacksRequest), arg0)
+}
+
+// DescribeStacksWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeStacksWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.Option) (*cloudformation.DescribeStacksOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeStacksWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeStacksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeStacksWithContext indicates an expected call of DescribeStacksWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeStacksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStacksWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeStacksWithContext), varargs...)
+}
+
+// DescribeType mocks base method.
+func (m *MockCloudFormationAPI) DescribeType(arg0 *cloudformation.DescribeTypeInput) (*cloudformation.DescribeTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeType", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeType indicates an expected call of DescribeType.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeType", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeType), arg0)
+}
+
+// DescribeTypeRegistration mocks base method.
+func (m *MockCloudFormationAPI) DescribeTypeRegistration(arg0 *cloudformation.DescribeTypeRegistrationInput) (*cloudformation.DescribeTypeRegistrationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeTypeRegistration", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeTypeRegistrationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeTypeRegistration indicates an expected call of DescribeTypeRegistration.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeTypeRegistration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTypeRegistration", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeTypeRegistration), arg0)
+}
+
+// DescribeTypeRegistrationRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeTypeRegistrationRequest(arg0 *cloudformation.DescribeTypeRegistrationInput) (*request.Request, *cloudformation.DescribeTypeRegistrationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeTypeRegistrationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeTypeRegistrationOutput)
+	return ret0, ret1
+}
+
+// DescribeTypeRegistrationRequest indicates an expected call of DescribeTypeRegistrationRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeTypeRegistrationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTypeRegistrationRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeTypeRegistrationRequest), arg0)
+}
+
+// DescribeTypeRegistrationWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeTypeRegistrationWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeTypeRegistrationInput, arg2 ...request.Option) (*cloudformation.DescribeTypeRegistrationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeTypeRegistrationWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeTypeRegistrationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeTypeRegistrationWithContext indicates an expected call of DescribeTypeRegistrationWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeTypeRegistrationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTypeRegistrationWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeTypeRegistrationWithContext), varargs...)
+}
+
+// DescribeTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeTypeRequest(arg0 *cloudformation.DescribeTypeInput) (*request.Request, *cloudformation.DescribeTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeTypeOutput)
+	return ret0, ret1
+}
+
+// DescribeTypeRequest indicates an expected call of DescribeTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeTypeRequest), arg0)
+}
+
+// DescribeTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeTypeWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeTypeInput, arg2 ...request.Option) (*cloudformation.DescribeTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeTypeWithContext indicates an expected call of DescribeTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeTypeWithContext), varargs...)
+}
+
+// DetectStackDrift mocks base method.
+func (m *MockCloudFormationAPI) DetectStackDrift(arg0 *cloudformation.DetectStackDriftInput) (*cloudformation.DetectStackDriftOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackDrift", arg0)
+	ret0, _ := ret[0].(*cloudformation.DetectStackDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackDrift indicates an expected call of DetectStackDrift.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackDrift(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackDrift", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackDrift), arg0)
+}
+
+// DetectStackDriftRequest mocks base method.
+func (m *MockCloudFormationAPI) DetectStackDriftRequest(arg0 *cloudformation.DetectStackDriftInput) (*request.Request, *cloudformation.DetectStackDriftOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackDriftRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DetectStackDriftOutput)
+	return ret0, ret1
+}
+
+// DetectStackDriftRequest indicates an expected call of DetectStackDriftRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackDriftRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackDriftRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackDriftRequest), arg0)
+}
+
+// DetectStackDriftWithContext mocks base method.
+func (m *MockCloudFormationAPI) DetectStackDriftWithContext(arg0 aws.Context, arg1 *cloudformation.DetectStackDriftInput, arg2 ...request.Option) (*cloudformation.DetectStackDriftOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DetectStackDriftWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DetectStackDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackDriftWithContext indicates an expected call of DetectStackDriftWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackDriftWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackDriftWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackDriftWithContext), varargs...)
+}
+
+// DetectStackResourceDrift mocks base method.
+func (m *MockCloudFormationAPI) DetectStackResourceDrift(arg0 *cloudformation.DetectStackResourceDriftInput) (*cloudformation.DetectStackResourceDriftOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackResourceDrift", arg0)
+	ret0, _ := ret[0].(*cloudformation.DetectStackResourceDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackResourceDrift indicates an expected call of DetectStackResourceDrift.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackResourceDrift(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackResourceDrift", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackResourceDrift), arg0)
+}
+
+// DetectStackResourceDriftRequest mocks base method.
+func (m *MockCloudFormationAPI) DetectStackResourceDriftRequest(arg0 *cloudformation.DetectStackResourceDriftInput) (*request.Request, *cloudformation.DetectStackResourceDriftOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackResourceDriftRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DetectStackResourceDriftOutput)
+	return ret0, ret1
+}
+
+// DetectStackResourceDriftRequest indicates an expected call of DetectStackResourceDriftRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackResourceDriftRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackResourceDriftRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackResourceDriftRequest), arg0)
+}
+
+// DetectStackResourceDriftWithContext mocks base method.
+func (m *MockCloudFormationAPI) DetectStackResourceDriftWithContext(arg0 aws.Context, arg1 *cloudformation.DetectStackResourceDriftInput, arg2 ...request.Option) (*cloudformation.DetectStackResourceDriftOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DetectStackResourceDriftWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DetectStackResourceDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackResourceDriftWithContext indicates an expected call of DetectStackResourceDriftWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackResourceDriftWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackResourceDriftWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackResourceDriftWithContext), varargs...)
+}
+
+// DetectStackSetDrift mocks base method.
+func (m *MockCloudFormationAPI) DetectStackSetDrift(arg0 *cloudformation.DetectStackSetDriftInput) (*cloudformation.DetectStackSetDriftOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackSetDrift", arg0)
+	ret0, _ := ret[0].(*cloudformation.DetectStackSetDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackSetDrift indicates an expected call of DetectStackSetDrift.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackSetDrift(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackSetDrift", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackSetDrift), arg0)
+}
+
+// DetectStackSetDriftRequest mocks base method.
+func (m *MockCloudFormationAPI) DetectStackSetDriftRequest(arg0 *cloudformation.DetectStackSetDriftInput) (*request.Request, *cloudformation.DetectStackSetDriftOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetectStackSetDriftRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DetectStackSetDriftOutput)
+	return ret0, ret1
+}
+
+// DetectStackSetDriftRequest indicates an expected call of DetectStackSetDriftRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackSetDriftRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackSetDriftRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackSetDriftRequest), arg0)
+}
+
+// DetectStackSetDriftWithContext mocks base method.
+func (m *MockCloudFormationAPI) DetectStackSetDriftWithContext(arg0 aws.Context, arg1 *cloudformation.DetectStackSetDriftInput, arg2 ...request.Option) (*cloudformation.DetectStackSetDriftOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DetectStackSetDriftWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DetectStackSetDriftOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetectStackSetDriftWithContext indicates an expected call of DetectStackSetDriftWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DetectStackSetDriftWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetectStackSetDriftWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DetectStackSetDriftWithContext), varargs...)
+}
+
+// EstimateTemplateCost mocks base method.
+func (m *MockCloudFormationAPI) EstimateTemplateCost(arg0 *cloudformation.EstimateTemplateCostInput) (*cloudformation.EstimateTemplateCostOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EstimateTemplateCost", arg0)
+	ret0, _ := ret[0].(*cloudformation.EstimateTemplateCostOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EstimateTemplateCost indicates an expected call of EstimateTemplateCost.
+func (mr *MockCloudFormationAPIMockRecorder) EstimateTemplateCost(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateTemplateCost", reflect.TypeOf((*MockCloudFormationAPI)(nil).EstimateTemplateCost), arg0)
+}
+
+// EstimateTemplateCostRequest mocks base method.
+func (m *MockCloudFormationAPI) EstimateTemplateCostRequest(arg0 *cloudformation.EstimateTemplateCostInput) (*request.Request, *cloudformation.EstimateTemplateCostOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EstimateTemplateCostRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.EstimateTemplateCostOutput)
+	return ret0, ret1
+}
+
+// EstimateTemplateCostRequest indicates an expected call of EstimateTemplateCostRequest.
+func (mr *MockCloudFormationAPIMockRecorder) EstimateTemplateCostRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateTemplateCostRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).EstimateTemplateCostRequest), arg0)
+}
+
+// EstimateTemplateCostWithContext mocks base method.
+func (m *MockCloudFormationAPI) EstimateTemplateCostWithContext(arg0 aws.Context, arg1 *cloudformation.EstimateTemplateCostInput, arg2 ...request.Option) (*cloudformation.EstimateTemplateCostOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "EstimateTemplateCostWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.EstimateTemplateCostOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EstimateTemplateCostWithContext indicates an expected call of EstimateTemplateCostWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) EstimateTemplateCostWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateTemplateCostWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).EstimateTemplateCostWithContext), varargs...)
+}
+
+// ExecuteChangeSet mocks base method.
+func (m *MockCloudFormationAPI) ExecuteChangeSet(arg0 *cloudformation.ExecuteChangeSetInput) (*cloudformation.ExecuteChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteChangeSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.ExecuteChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteChangeSet indicates an expected call of ExecuteChangeSet.
+func (mr *MockCloudFormationAPIMockRecorder) ExecuteChangeSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteChangeSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).ExecuteChangeSet), arg0)
+}
+
+// ExecuteChangeSetRequest mocks base method.
+func (m *MockCloudFormationAPI) ExecuteChangeSetRequest(arg0 *cloudformation.ExecuteChangeSetInput) (*request.Request, *cloudformation.ExecuteChangeSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteChangeSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ExecuteChangeSetOutput)
+	return ret0, ret1
+}
+
+// ExecuteChangeSetRequest indicates an expected call of ExecuteChangeSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ExecuteChangeSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteChangeSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ExecuteChangeSetRequest), arg0)
+}
+
+// ExecuteChangeSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) ExecuteChangeSetWithContext(arg0 aws.Context, arg1 *cloudformation.ExecuteChangeSetInput, arg2 ...request.Option) (*cloudformation.ExecuteChangeSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ExecuteChangeSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ExecuteChangeSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteChangeSetWithContext indicates an expected call of ExecuteChangeSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ExecuteChangeSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ExecuteChangeSetWithContext), varargs...)
+}
+
+// GetStackPolicy mocks base method.
+func (m *MockCloudFormationAPI) GetStackPolicy(arg0 *cloudformation.GetStackPolicyInput) (*cloudformation.GetStackPolicyOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStackPolicy", arg0)
+	ret0, _ := ret[0].(*cloudformation.GetStackPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStackPolicy indicates an expected call of GetStackPolicy.
+func (mr *MockCloudFormationAPIMockRecorder) GetStackPolicy(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStackPolicy", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetStackPolicy), arg0)
+}
+
+// GetStackPolicyRequest mocks base method.
+func (m *MockCloudFormationAPI) GetStackPolicyRequest(arg0 *cloudformation.GetStackPolicyInput) (*request.Request, *cloudformation.GetStackPolicyOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStackPolicyRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.GetStackPolicyOutput)
+	return ret0, ret1
+}
+
+// GetStackPolicyRequest indicates an expected call of GetStackPolicyRequest.
+func (mr *MockCloudFormationAPIMockRecorder) GetStackPolicyRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStackPolicyRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetStackPolicyRequest), arg0)
+}
+
+// GetStackPolicyWithContext mocks base method.
+func (m *MockCloudFormationAPI) GetStackPolicyWithContext(arg0 aws.Context, arg1 *cloudformation.GetStackPolicyInput, arg2 ...request.Option) (*cloudformation.GetStackPolicyOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetStackPolicyWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.GetStackPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStackPolicyWithContext indicates an expected call of GetStackPolicyWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) GetStackPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStackPolicyWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetStackPolicyWithContext), varargs...)
+}
+
+// GetTemplate mocks base method.
+func (m *MockCloudFormationAPI) GetTemplate(arg0 *cloudformation.GetTemplateInput) (*cloudformation.GetTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.GetTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplate indicates an expected call of GetTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplate), arg0)
+}
+
+// GetTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) GetTemplateRequest(arg0 *cloudformation.GetTemplateInput) (*request.Request, *cloudformation.GetTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.GetTemplateOutput)
+	return ret0, ret1
+}
+
+// GetTemplateRequest indicates an expected call of GetTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplateRequest), arg0)
+}
+
+// GetTemplateSummary mocks base method.
+func (m *MockCloudFormationAPI) GetTemplateSummary(arg0 *cloudformation.GetTemplateSummaryInput) (*cloudformation.GetTemplateSummaryOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplateSummary", arg0)
+	ret0, _ := ret[0].(*cloudformation.GetTemplateSummaryOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplateSummary indicates an expected call of GetTemplateSummary.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplateSummary(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateSummary", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplateSummary), arg0)
+}
+
+// GetTemplateSummaryRequest mocks base method.
+func (m *MockCloudFormationAPI) GetTemplateSummaryRequest(arg0 *cloudformation.GetTemplateSummaryInput) (*request.Request, *cloudformation.GetTemplateSummaryOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTemplateSummaryRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.GetTemplateSummaryOutput)
+	return ret0, ret1
+}
+
+// GetTemplateSummaryRequest indicates an expected call of GetTemplateSummaryRequest.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplateSummaryRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateSummaryRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplateSummaryRequest), arg0)
+}
+
+// GetTemplateSummaryWithContext mocks base method.
+func (m *MockCloudFormationAPI) GetTemplateSummaryWithContext(arg0 aws.Context, arg1 *cloudformation.GetTemplateSummaryInput, arg2 ...request.Option) (*cloudformation.GetTemplateSummaryOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTemplateSummaryWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.GetTemplateSummaryOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplateSummaryWithContext indicates an expected call of GetTemplateSummaryWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplateSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateSummaryWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplateSummaryWithContext), varargs...)
+}
+
+// GetTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) GetTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.GetTemplateInput, arg2 ...request.Option) (*cloudformation.GetTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.GetTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTemplateWithContext indicates an expected call of GetTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) GetTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetTemplateWithContext), varargs...)
+}
+
+// ImportStacksToStackSet mocks base method.
+func (m *MockCloudFormationAPI) ImportStacksToStackSet(arg0 *cloudformation.ImportStacksToStackSetInput) (*cloudformation.ImportStacksToStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImportStacksToStackSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.ImportStacksToStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImportStacksToStackSet indicates an expected call of ImportStacksToStackSet.
+func (mr *MockCloudFormationAPIMockRecorder) ImportStacksToStackSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportStacksToStackSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).ImportStacksToStackSet), arg0)
+}
+
+// ImportStacksToStackSetRequest mocks base method.
+func (m *MockCloudFormationAPI) ImportStacksToStackSetRequest(arg0 *cloudformation.ImportStacksToStackSetInput) (*request.Request, *cloudformation.ImportStacksToStackSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImportStacksToStackSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ImportStacksToStackSetOutput)
+	return ret0, ret1
+}
+
+// ImportStacksToStackSetRequest indicates an expected call of ImportStacksToStackSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ImportStacksToStackSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportStacksToStackSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ImportStacksToStackSetRequest), arg0)
+}
+
+// ImportStacksToStackSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) ImportStacksToStackSetWithContext(arg0 aws.Context, arg1 *cloudformation.ImportStacksToStackSetInput, arg2 ...request.Option) (*cloudformation.ImportStacksToStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ImportStacksToStackSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ImportStacksToStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImportStacksToStackSetWithContext indicates an expected call of ImportStacksToStackSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ImportStacksToStackSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportStacksToStackSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ImportStacksToStackSetWithContext), varargs...)
+}
+
+// ListChangeSets mocks base method.
+func (m *MockCloudFormationAPI) ListChangeSets(arg0 *cloudformation.ListChangeSetsInput) (*cloudformation.ListChangeSetsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListChangeSets", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListChangeSetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListChangeSets indicates an expected call of ListChangeSets.
+func (mr *MockCloudFormationAPIMockRecorder) ListChangeSets(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChangeSets", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListChangeSets), arg0)
+}
+
+// ListChangeSetsPages mocks base method.
+func (m *MockCloudFormationAPI) ListChangeSetsPages(arg0 *cloudformation.ListChangeSetsInput, arg1 func(*cloudformation.ListChangeSetsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListChangeSetsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListChangeSetsPages indicates an expected call of ListChangeSetsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListChangeSetsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChangeSetsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListChangeSetsPages), arg0, arg1)
+}
+
+// ListChangeSetsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListChangeSetsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListChangeSetsInput, arg2 func(*cloudformation.ListChangeSetsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListChangeSetsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListChangeSetsPagesWithContext indicates an expected call of ListChangeSetsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListChangeSetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChangeSetsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListChangeSetsPagesWithContext), varargs...)
+}
+
+// ListChangeSetsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListChangeSetsRequest(arg0 *cloudformation.ListChangeSetsInput) (*request.Request, *cloudformation.ListChangeSetsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListChangeSetsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListChangeSetsOutput)
+	return ret0, ret1
+}
+
+// ListChangeSetsRequest indicates an expected call of ListChangeSetsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListChangeSetsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChangeSetsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListChangeSetsRequest), arg0)
+}
+
+// ListChangeSetsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListChangeSetsWithContext(arg0 aws.Context, arg1 *cloudformation.ListChangeSetsInput, arg2 ...request.Option) (*cloudformation.ListChangeSetsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListChangeSetsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListChangeSetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListChangeSetsWithContext indicates an expected call of ListChangeSetsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListChangeSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChangeSetsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListChangeSetsWithContext), varargs...)
+}
+
+// ListExports mocks base method.
+func (m *MockCloudFormationAPI) ListExports(arg0 *cloudformation.ListExportsInput) (*cloudformation.ListExportsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListExports", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListExportsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListExports indicates an expected call of ListExports.
+func (mr *MockCloudFormationAPIMockRecorder) ListExports(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExports", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExports), arg0)
+}
+
+// ListExportsPages mocks base method.
+func (m *MockCloudFormationAPI) ListExportsPages(arg0 *cloudformation.ListExportsInput, arg1 func(*cloudformation.ListExportsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListExportsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListExportsPages indicates an expected call of ListExportsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListExportsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExportsPages), arg0, arg1)
+}
+
+// ListExportsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListExportsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListExportsInput, arg2 func(*cloudformation.ListExportsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListExportsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListExportsPagesWithContext indicates an expected call of ListExportsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListExportsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExportsPagesWithContext), varargs...)
+}
+
+// ListExportsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListExportsRequest(arg0 *cloudformation.ListExportsInput) (*request.Request, *cloudformation.ListExportsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListExportsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListExportsOutput)
+	return ret0, ret1
+}
+
+// ListExportsRequest indicates an expected call of ListExportsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListExportsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExportsRequest), arg0)
+}
+
+// ListExportsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListExportsWithContext(arg0 aws.Context, arg1 *cloudformation.ListExportsInput, arg2 ...request.Option) (*cloudformation.ListExportsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListExportsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListExportsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListExportsWithContext indicates an expected call of ListExportsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListExportsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExportsWithContext), varargs...)
+}
+
+// ListImports mocks base method.
+func (m *MockCloudFormationAPI) ListImports(arg0 *cloudformation.ListImportsInput) (*cloudformation.ListImportsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListImports", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListImportsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListImports indicates an expected call of ListImports.
+func (mr *MockCloudFormationAPIMockRecorder) ListImports(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImports", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImports), arg0)
+}
+
+// ListImportsPages mocks base method.
+func (m *MockCloudFormationAPI) ListImportsPages(arg0 *cloudformation.ListImportsInput, arg1 func(*cloudformation.ListImportsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListImportsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListImportsPages indicates an expected call of ListImportsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListImportsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImportsPages), arg0, arg1)
+}
+
+// ListImportsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListImportsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListImportsInput, arg2 func(*cloudformation.ListImportsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListImportsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListImportsPagesWithContext indicates an expected call of ListImportsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListImportsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImportsPagesWithContext), varargs...)
+}
+
+// ListImportsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListImportsRequest(arg0 *cloudformation.ListImportsInput) (*request.Request, *cloudformation.ListImportsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListImportsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListImportsOutput)
+	return ret0, ret1
+}
+
+// ListImportsRequest indicates an expected call of ListImportsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListImportsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImportsRequest), arg0)
+}
+
+// ListImportsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListImportsWithContext(arg0 aws.Context, arg1 *cloudformation.ListImportsInput, arg2 ...request.Option) (*cloudformation.ListImportsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListImportsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListImportsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListImportsWithContext indicates an expected call of ListImportsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListImportsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImportsWithContext), varargs...)
+}
+
+// ListStackInstanceResourceDrifts mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstanceResourceDrifts(arg0 *cloudformation.ListStackInstanceResourceDriftsInput) (*cloudformation.ListStackInstanceResourceDriftsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackInstanceResourceDrifts", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackInstanceResourceDriftsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackInstanceResourceDrifts indicates an expected call of ListStackInstanceResourceDrifts.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstanceResourceDrifts(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstanceResourceDrifts", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstanceResourceDrifts), arg0)
+}
+
+// ListStackInstanceResourceDriftsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstanceResourceDriftsRequest(arg0 *cloudformation.ListStackInstanceResourceDriftsInput) (*request.Request, *cloudformation.ListStackInstanceResourceDriftsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackInstanceResourceDriftsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackInstanceResourceDriftsOutput)
+	return ret0, ret1
+}
+
+// ListStackInstanceResourceDriftsRequest indicates an expected call of ListStackInstanceResourceDriftsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstanceResourceDriftsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstanceResourceDriftsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstanceResourceDriftsRequest), arg0)
+}
+
+// ListStackInstanceResourceDriftsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstanceResourceDriftsWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackInstanceResourceDriftsInput, arg2 ...request.Option) (*cloudformation.ListStackInstanceResourceDriftsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackInstanceResourceDriftsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackInstanceResourceDriftsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackInstanceResourceDriftsWithContext indicates an expected call of ListStackInstanceResourceDriftsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstanceResourceDriftsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstanceResourceDriftsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstanceResourceDriftsWithContext), varargs...)
+}
+
+// ListStackInstances mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstances(arg0 *cloudformation.ListStackInstancesInput) (*cloudformation.ListStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackInstances", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackInstances indicates an expected call of ListStackInstances.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstances(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstances", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstances), arg0)
+}
+
+// ListStackInstancesPages mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstancesPages(arg0 *cloudformation.ListStackInstancesInput, arg1 func(*cloudformation.ListStackInstancesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackInstancesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackInstancesPages indicates an expected call of ListStackInstancesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstancesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstancesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstancesPages), arg0, arg1)
+}
+
+// ListStackInstancesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstancesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackInstancesInput, arg2 func(*cloudformation.ListStackInstancesOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackInstancesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackInstancesPagesWithContext indicates an expected call of ListStackInstancesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstancesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstancesPagesWithContext), varargs...)
+}
+
+// ListStackInstancesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstancesRequest(arg0 *cloudformation.ListStackInstancesInput) (*request.Request, *cloudformation.ListStackInstancesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackInstancesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackInstancesOutput)
+	return ret0, ret1
+}
+
+// ListStackInstancesRequest indicates an expected call of ListStackInstancesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstancesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstancesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstancesRequest), arg0)
+}
+
+// ListStackInstancesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackInstancesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackInstancesInput, arg2 ...request.Option) (*cloudformation.ListStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackInstancesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackInstancesWithContext indicates an expected call of ListStackInstancesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackInstancesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackInstancesWithContext), varargs...)
+}
+
+// ListStackResources mocks base method.
+func (m *MockCloudFormationAPI) ListStackResources(arg0 *cloudformation.ListStackResourcesInput) (*cloudformation.ListStackResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackResources", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackResources indicates an expected call of ListStackResources.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackResources(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResources", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResources), arg0)
+}
+
+// ListStackResourcesPages mocks base method.
+func (m *MockCloudFormationAPI) ListStackResourcesPages(arg0 *cloudformation.ListStackResourcesInput, arg1 func(*cloudformation.ListStackResourcesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackResourcesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackResourcesPages indicates an expected call of ListStackResourcesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackResourcesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResourcesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResourcesPages), arg0, arg1)
+}
+
+// ListStackResourcesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackResourcesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackResourcesInput, arg2 func(*cloudformation.ListStackResourcesOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackResourcesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackResourcesPagesWithContext indicates an expected call of ListStackResourcesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackResourcesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResourcesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResourcesPagesWithContext), varargs...)
+}
+
+// ListStackResourcesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackResourcesRequest(arg0 *cloudformation.ListStackResourcesInput) (*request.Request, *cloudformation.ListStackResourcesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackResourcesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackResourcesOutput)
+	return ret0, ret1
+}
+
+// ListStackResourcesRequest indicates an expected call of ListStackResourcesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackResourcesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResourcesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResourcesRequest), arg0)
+}
+
+// ListStackResourcesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackResourcesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackResourcesInput, arg2 ...request.Option) (*cloudformation.ListStackResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackResourcesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackResourcesWithContext indicates an expected call of ListStackResourcesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResourcesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResourcesWithContext), varargs...)
+}
+
+// ListStackSetOperationResults mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationResults(arg0 *cloudformation.ListStackSetOperationResultsInput) (*cloudformation.ListStackSetOperationResultsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperationResults", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetOperationResultsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetOperationResults indicates an expected call of ListStackSetOperationResults.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationResults(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationResults", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationResults), arg0)
+}
+
+// ListStackSetOperationResultsPages mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationResultsPages(arg0 *cloudformation.ListStackSetOperationResultsInput, arg1 func(*cloudformation.ListStackSetOperationResultsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperationResultsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetOperationResultsPages indicates an expected call of ListStackSetOperationResultsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationResultsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationResultsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationResultsPages), arg0, arg1)
+}
+
+// ListStackSetOperationResultsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationResultsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetOperationResultsInput, arg2 func(*cloudformation.ListStackSetOperationResultsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetOperationResultsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetOperationResultsPagesWithContext indicates an expected call of ListStackSetOperationResultsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationResultsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationResultsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationResultsPagesWithContext), varargs...)
+}
+
+// ListStackSetOperationResultsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationResultsRequest(arg0 *cloudformation.ListStackSetOperationResultsInput) (*request.Request, *cloudformation.ListStackSetOperationResultsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperationResultsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackSetOperationResultsOutput)
+	return ret0, ret1
+}
+
+// ListStackSetOperationResultsRequest indicates an expected call of ListStackSetOperationResultsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationResultsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationResultsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationResultsRequest), arg0)
+}
+
+// ListStackSetOperationResultsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationResultsWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetOperationResultsInput, arg2 ...request.Option) (*cloudformation.ListStackSetOperationResultsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetOperationResultsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetOperationResultsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetOperationResultsWithContext indicates an expected call of ListStackSetOperationResultsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationResultsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationResultsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationResultsWithContext), varargs...)
+}
+
+// ListStackSetOperations mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperations(arg0 *cloudformation.ListStackSetOperationsInput) (*cloudformation.ListStackSetOperationsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperations", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetOperationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetOperations indicates an expected call of ListStackSetOperations.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperations(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperations", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperations), arg0)
+}
+
+// ListStackSetOperationsPages mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationsPages(arg0 *cloudformation.ListStackSetOperationsInput, arg1 func(*cloudformation.ListStackSetOperationsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperationsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetOperationsPages indicates an expected call of ListStackSetOperationsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationsPages), arg0, arg1)
+}
+
+// ListStackSetOperationsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetOperationsInput, arg2 func(*cloudformation.ListStackSetOperationsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetOperationsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetOperationsPagesWithContext indicates an expected call of ListStackSetOperationsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationsPagesWithContext), varargs...)
+}
+
+// ListStackSetOperationsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationsRequest(arg0 *cloudformation.ListStackSetOperationsInput) (*request.Request, *cloudformation.ListStackSetOperationsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetOperationsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackSetOperationsOutput)
+	return ret0, ret1
+}
+
+// ListStackSetOperationsRequest indicates an expected call of ListStackSetOperationsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationsRequest), arg0)
+}
+
+// ListStackSetOperationsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetOperationsWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetOperationsInput, arg2 ...request.Option) (*cloudformation.ListStackSetOperationsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetOperationsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetOperationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetOperationsWithContext indicates an expected call of ListStackSetOperationsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetOperationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetOperationsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetOperationsWithContext), varargs...)
+}
+
+// ListStackSets mocks base method.
+func (m *MockCloudFormationAPI) ListStackSets(arg0 *cloudformation.ListStackSetsInput) (*cloudformation.ListStackSetsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSets", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSets indicates an expected call of ListStackSets.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSets(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSets", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSets), arg0)
+}
+
+// ListStackSetsPages mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetsPages(arg0 *cloudformation.ListStackSetsInput, arg1 func(*cloudformation.ListStackSetsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetsPages indicates an expected call of ListStackSetsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetsPages), arg0, arg1)
+}
+
+// ListStackSetsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetsInput, arg2 func(*cloudformation.ListStackSetsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStackSetsPagesWithContext indicates an expected call of ListStackSetsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetsPagesWithContext), varargs...)
+}
+
+// ListStackSetsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetsRequest(arg0 *cloudformation.ListStackSetsInput) (*request.Request, *cloudformation.ListStackSetsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackSetsOutput)
+	return ret0, ret1
+}
+
+// ListStackSetsRequest indicates an expected call of ListStackSetsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetsRequest), arg0)
+}
+
+// ListStackSetsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetsWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetsInput, arg2 ...request.Option) (*cloudformation.ListStackSetsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetsWithContext indicates an expected call of ListStackSetsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetsWithContext), varargs...)
+}
+
+// ListStacks mocks base method.
+func (m *MockCloudFormationAPI) ListStacks(arg0 *cloudformation.ListStacksInput) (*cloudformation.ListStacksOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStacks", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStacksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStacks indicates an expected call of ListStacks.
+func (mr *MockCloudFormationAPIMockRecorder) ListStacks(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStacks", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStacks), arg0)
+}
+
+// ListStacksPages mocks base method.
+func (m *MockCloudFormationAPI) ListStacksPages(arg0 *cloudformation.ListStacksInput, arg1 func(*cloudformation.ListStacksOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStacksPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStacksPages indicates an expected call of ListStacksPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListStacksPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStacksPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStacksPages), arg0, arg1)
+}
+
+// ListStacksPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStacksPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListStacksInput, arg2 func(*cloudformation.ListStacksOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStacksPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListStacksPagesWithContext indicates an expected call of ListStacksPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStacksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStacksPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStacksPagesWithContext), varargs...)
+}
+
+// ListStacksRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStacksRequest(arg0 *cloudformation.ListStacksInput) (*request.Request, *cloudformation.ListStacksOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStacksRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStacksOutput)
+	return ret0, ret1
+}
+
+// ListStacksRequest indicates an expected call of ListStacksRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStacksRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStacksRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStacksRequest), arg0)
+}
+
+// ListStacksWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStacksWithContext(arg0 aws.Context, arg1 *cloudformation.ListStacksInput, arg2 ...request.Option) (*cloudformation.ListStacksOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStacksWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStacksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStacksWithContext indicates an expected call of ListStacksWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStacksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStacksWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStacksWithContext), varargs...)
+}
+
+// ListTypeRegistrations mocks base method.
+func (m *MockCloudFormationAPI) ListTypeRegistrations(arg0 *cloudformation.ListTypeRegistrationsInput) (*cloudformation.ListTypeRegistrationsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeRegistrations", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListTypeRegistrationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypeRegistrations indicates an expected call of ListTypeRegistrations.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeRegistrations(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeRegistrations", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeRegistrations), arg0)
+}
+
+// ListTypeRegistrationsPages mocks base method.
+func (m *MockCloudFormationAPI) ListTypeRegistrationsPages(arg0 *cloudformation.ListTypeRegistrationsInput, arg1 func(*cloudformation.ListTypeRegistrationsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeRegistrationsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypeRegistrationsPages indicates an expected call of ListTypeRegistrationsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeRegistrationsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeRegistrationsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeRegistrationsPages), arg0, arg1)
+}
+
+// ListTypeRegistrationsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypeRegistrationsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypeRegistrationsInput, arg2 func(*cloudformation.ListTypeRegistrationsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypeRegistrationsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypeRegistrationsPagesWithContext indicates an expected call of ListTypeRegistrationsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeRegistrationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeRegistrationsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeRegistrationsPagesWithContext), varargs...)
+}
+
+// ListTypeRegistrationsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListTypeRegistrationsRequest(arg0 *cloudformation.ListTypeRegistrationsInput) (*request.Request, *cloudformation.ListTypeRegistrationsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeRegistrationsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListTypeRegistrationsOutput)
+	return ret0, ret1
+}
+
+// ListTypeRegistrationsRequest indicates an expected call of ListTypeRegistrationsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeRegistrationsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeRegistrationsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeRegistrationsRequest), arg0)
+}
+
+// ListTypeRegistrationsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypeRegistrationsWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypeRegistrationsInput, arg2 ...request.Option) (*cloudformation.ListTypeRegistrationsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypeRegistrationsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListTypeRegistrationsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypeRegistrationsWithContext indicates an expected call of ListTypeRegistrationsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeRegistrationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeRegistrationsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeRegistrationsWithContext), varargs...)
+}
+
+// ListTypeVersions mocks base method.
+func (m *MockCloudFormationAPI) ListTypeVersions(arg0 *cloudformation.ListTypeVersionsInput) (*cloudformation.ListTypeVersionsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeVersions", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListTypeVersionsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypeVersions indicates an expected call of ListTypeVersions.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeVersions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeVersions", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeVersions), arg0)
+}
+
+// ListTypeVersionsPages mocks base method.
+func (m *MockCloudFormationAPI) ListTypeVersionsPages(arg0 *cloudformation.ListTypeVersionsInput, arg1 func(*cloudformation.ListTypeVersionsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeVersionsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypeVersionsPages indicates an expected call of ListTypeVersionsPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeVersionsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeVersionsPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeVersionsPages), arg0, arg1)
+}
+
+// ListTypeVersionsPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypeVersionsPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypeVersionsInput, arg2 func(*cloudformation.ListTypeVersionsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypeVersionsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypeVersionsPagesWithContext indicates an expected call of ListTypeVersionsPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeVersionsPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeVersionsPagesWithContext), varargs...)
+}
+
+// ListTypeVersionsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListTypeVersionsRequest(arg0 *cloudformation.ListTypeVersionsInput) (*request.Request, *cloudformation.ListTypeVersionsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypeVersionsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListTypeVersionsOutput)
+	return ret0, ret1
+}
+
+// ListTypeVersionsRequest indicates an expected call of ListTypeVersionsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeVersionsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeVersionsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeVersionsRequest), arg0)
+}
+
+// ListTypeVersionsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypeVersionsWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypeVersionsInput, arg2 ...request.Option) (*cloudformation.ListTypeVersionsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypeVersionsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListTypeVersionsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypeVersionsWithContext indicates an expected call of ListTypeVersionsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypeVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypeVersionsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypeVersionsWithContext), varargs...)
+}
+
+// ListTypes mocks base method.
+func (m *MockCloudFormationAPI) ListTypes(arg0 *cloudformation.ListTypesInput) (*cloudformation.ListTypesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypes", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListTypesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypes indicates an expected call of ListTypes.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypes", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypes), arg0)
+}
+
+// ListTypesPages mocks base method.
+func (m *MockCloudFormationAPI) ListTypesPages(arg0 *cloudformation.ListTypesInput, arg1 func(*cloudformation.ListTypesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypesPages indicates an expected call of ListTypesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypesPages), arg0, arg1)
+}
+
+// ListTypesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypesInput, arg2 func(*cloudformation.ListTypesOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListTypesPagesWithContext indicates an expected call of ListTypesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypesPagesWithContext), varargs...)
+}
+
+// ListTypesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListTypesRequest(arg0 *cloudformation.ListTypesInput) (*request.Request, *cloudformation.ListTypesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTypesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListTypesOutput)
+	return ret0, ret1
+}
+
+// ListTypesRequest indicates an expected call of ListTypesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypesRequest), arg0)
+}
+
+// ListTypesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListTypesWithContext(arg0 aws.Context, arg1 *cloudformation.ListTypesInput, arg2 ...request.Option) (*cloudformation.ListTypesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTypesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListTypesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTypesWithContext indicates an expected call of ListTypesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTypesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListTypesWithContext), varargs...)
+}
+
+// PublishType mocks base method.
+func (m *MockCloudFormationAPI) PublishType(arg0 *cloudformation.PublishTypeInput) (*cloudformation.PublishTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishType", arg0)
+	ret0, _ := ret[0].(*cloudformation.PublishTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishType indicates an expected call of PublishType.
+func (mr *MockCloudFormationAPIMockRecorder) PublishType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishType", reflect.TypeOf((*MockCloudFormationAPI)(nil).PublishType), arg0)
+}
+
+// PublishTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) PublishTypeRequest(arg0 *cloudformation.PublishTypeInput) (*request.Request, *cloudformation.PublishTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.PublishTypeOutput)
+	return ret0, ret1
+}
+
+// PublishTypeRequest indicates an expected call of PublishTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) PublishTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).PublishTypeRequest), arg0)
+}
+
+// PublishTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) PublishTypeWithContext(arg0 aws.Context, arg1 *cloudformation.PublishTypeInput, arg2 ...request.Option) (*cloudformation.PublishTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PublishTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.PublishTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishTypeWithContext indicates an expected call of PublishTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) PublishTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).PublishTypeWithContext), varargs...)
+}
+
+// RecordHandlerProgress mocks base method.
+func (m *MockCloudFormationAPI) RecordHandlerProgress(arg0 *cloudformation.RecordHandlerProgressInput) (*cloudformation.RecordHandlerProgressOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RecordHandlerProgress", arg0)
+	ret0, _ := ret[0].(*cloudformation.RecordHandlerProgressOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RecordHandlerProgress indicates an expected call of RecordHandlerProgress.
+func (mr *MockCloudFormationAPIMockRecorder) RecordHandlerProgress(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordHandlerProgress", reflect.TypeOf((*MockCloudFormationAPI)(nil).RecordHandlerProgress), arg0)
+}
+
+// RecordHandlerProgressRequest mocks base method.
+func (m *MockCloudFormationAPI) RecordHandlerProgressRequest(arg0 *cloudformation.RecordHandlerProgressInput) (*request.Request, *cloudformation.RecordHandlerProgressOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RecordHandlerProgressRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.RecordHandlerProgressOutput)
+	return ret0, ret1
+}
+
+// RecordHandlerProgressRequest indicates an expected call of RecordHandlerProgressRequest.
+func (mr *MockCloudFormationAPIMockRecorder) RecordHandlerProgressRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordHandlerProgressRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).RecordHandlerProgressRequest), arg0)
+}
+
+// RecordHandlerProgressWithContext mocks base method.
+func (m *MockCloudFormationAPI) RecordHandlerProgressWithContext(arg0 aws.Context, arg1 *cloudformation.RecordHandlerProgressInput, arg2 ...request.Option) (*cloudformation.RecordHandlerProgressOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RecordHandlerProgressWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.RecordHandlerProgressOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RecordHandlerProgressWithContext indicates an expected call of RecordHandlerProgressWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) RecordHandlerProgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordHandlerProgressWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).RecordHandlerProgressWithContext), varargs...)
+}
+
+// RegisterPublisher mocks base method.
+func (m *MockCloudFormationAPI) RegisterPublisher(arg0 *cloudformation.RegisterPublisherInput) (*cloudformation.RegisterPublisherOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterPublisher", arg0)
+	ret0, _ := ret[0].(*cloudformation.RegisterPublisherOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RegisterPublisher indicates an expected call of RegisterPublisher.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterPublisher(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPublisher", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterPublisher), arg0)
+}
+
+// RegisterPublisherRequest mocks base method.
+func (m *MockCloudFormationAPI) RegisterPublisherRequest(arg0 *cloudformation.RegisterPublisherInput) (*request.Request, *cloudformation.RegisterPublisherOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterPublisherRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.RegisterPublisherOutput)
+	return ret0, ret1
+}
+
+// RegisterPublisherRequest indicates an expected call of RegisterPublisherRequest.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterPublisherRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPublisherRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterPublisherRequest), arg0)
+}
+
+// RegisterPublisherWithContext mocks base method.
+func (m *MockCloudFormationAPI) RegisterPublisherWithContext(arg0 aws.Context, arg1 *cloudformation.RegisterPublisherInput, arg2 ...request.Option) (*cloudformation.RegisterPublisherOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RegisterPublisherWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.RegisterPublisherOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RegisterPublisherWithContext indicates an expected call of RegisterPublisherWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterPublisherWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPublisherWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterPublisherWithContext), varargs...)
+}
+
+// RegisterType mocks base method.
+func (m *MockCloudFormationAPI) RegisterType(arg0 *cloudformation.RegisterTypeInput) (*cloudformation.RegisterTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterType", arg0)
+	ret0, _ := ret[0].(*cloudformation.RegisterTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RegisterType indicates an expected call of RegisterType.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterType", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterType), arg0)
+}
+
+// RegisterTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) RegisterTypeRequest(arg0 *cloudformation.RegisterTypeInput) (*request.Request, *cloudformation.RegisterTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.RegisterTypeOutput)
+	return ret0, ret1
+}
+
+// RegisterTypeRequest indicates an expected call of RegisterTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterTypeRequest), arg0)
+}
+
+// RegisterTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) RegisterTypeWithContext(arg0 aws.Context, arg1 *cloudformation.RegisterTypeInput, arg2 ...request.Option) (*cloudformation.RegisterTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RegisterTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.RegisterTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RegisterTypeWithContext indicates an expected call of RegisterTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) RegisterTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).RegisterTypeWithContext), varargs...)
+}
+
+// RollbackStack mocks base method.
+func (m *MockCloudFormationAPI) RollbackStack(arg0 *cloudformation.RollbackStackInput) (*cloudformation.RollbackStackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RollbackStack", arg0)
+	ret0, _ := ret[0].(*cloudformation.RollbackStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RollbackStack indicates an expected call of RollbackStack.
+func (mr *MockCloudFormationAPIMockRecorder) RollbackStack(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackStack", reflect.TypeOf((*MockCloudFormationAPI)(nil).RollbackStack), arg0)
+}
+
+// RollbackStackRequest mocks base method.
+func (m *MockCloudFormationAPI) RollbackStackRequest(arg0 *cloudformation.RollbackStackInput) (*request.Request, *cloudformation.RollbackStackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RollbackStackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.RollbackStackOutput)
+	return ret0, ret1
+}
+
+// RollbackStackRequest indicates an expected call of RollbackStackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) RollbackStackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackStackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).RollbackStackRequest), arg0)
+}
+
+// RollbackStackWithContext mocks base method.
+func (m *MockCloudFormationAPI) RollbackStackWithContext(arg0 aws.Context, arg1 *cloudformation.RollbackStackInput, arg2 ...request.Option) (*cloudformation.RollbackStackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RollbackStackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.RollbackStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RollbackStackWithContext indicates an expected call of RollbackStackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) RollbackStackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackStackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).RollbackStackWithContext), varargs...)
+}
+
+// SetStackPolicy mocks base method.
+func (m *MockCloudFormationAPI) SetStackPolicy(arg0 *cloudformation.SetStackPolicyInput) (*cloudformation.SetStackPolicyOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetStackPolicy", arg0)
+	ret0, _ := ret[0].(*cloudformation.SetStackPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetStackPolicy indicates an expected call of SetStackPolicy.
+func (mr *MockCloudFormationAPIMockRecorder) SetStackPolicy(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStackPolicy", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetStackPolicy), arg0)
+}
+
+// SetStackPolicyRequest mocks base method.
+func (m *MockCloudFormationAPI) SetStackPolicyRequest(arg0 *cloudformation.SetStackPolicyInput) (*request.Request, *cloudformation.SetStackPolicyOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetStackPolicyRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.SetStackPolicyOutput)
+	return ret0, ret1
+}
+
+// SetStackPolicyRequest indicates an expected call of SetStackPolicyRequest.
+func (mr *MockCloudFormationAPIMockRecorder) SetStackPolicyRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStackPolicyRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetStackPolicyRequest), arg0)
+}
+
+// SetStackPolicyWithContext mocks base method.
+func (m *MockCloudFormationAPI) SetStackPolicyWithContext(arg0 aws.Context, arg1 *cloudformation.SetStackPolicyInput, arg2 ...request.Option) (*cloudformation.SetStackPolicyOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetStackPolicyWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.SetStackPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetStackPolicyWithContext indicates an expected call of SetStackPolicyWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) SetStackPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStackPolicyWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetStackPolicyWithContext), varargs...)
+}
+
+// SetTypeConfiguration mocks base method.
+func (m *MockCloudFormationAPI) SetTypeConfiguration(arg0 *cloudformation.SetTypeConfigurationInput) (*cloudformation.SetTypeConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetTypeConfiguration", arg0)
+	ret0, _ := ret[0].(*cloudformation.SetTypeConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetTypeConfiguration indicates an expected call of SetTypeConfiguration.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeConfiguration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeConfiguration", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeConfiguration), arg0)
+}
+
+// SetTypeConfigurationRequest mocks base method.
+func (m *MockCloudFormationAPI) SetTypeConfigurationRequest(arg0 *cloudformation.SetTypeConfigurationInput) (*request.Request, *cloudformation.SetTypeConfigurationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetTypeConfigurationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.SetTypeConfigurationOutput)
+	return ret0, ret1
+}
+
+// SetTypeConfigurationRequest indicates an expected call of SetTypeConfigurationRequest.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeConfigurationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeConfigurationRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeConfigurationRequest), arg0)
+}
+
+// SetTypeConfigurationWithContext mocks base method.
+func (m *MockCloudFormationAPI) SetTypeConfigurationWithContext(arg0 aws.Context, arg1 *cloudformation.SetTypeConfigurationInput, arg2 ...request.Option) (*cloudformation.SetTypeConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetTypeConfigurationWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.SetTypeConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetTypeConfigurationWithContext indicates an expected call of SetTypeConfigurationWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeConfigurationWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeConfigurationWithContext), varargs...)
+}
+
+// SetTypeDefaultVersion mocks base method.
+func (m *MockCloudFormationAPI) SetTypeDefaultVersion(arg0 *cloudformation.SetTypeDefaultVersionInput) (*cloudformation.SetTypeDefaultVersionOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetTypeDefaultVersion", arg0)
+	ret0, _ := ret[0].(*cloudformation.SetTypeDefaultVersionOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetTypeDefaultVersion indicates an expected call of SetTypeDefaultVersion.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeDefaultVersion(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeDefaultVersion", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeDefaultVersion), arg0)
+}
+
+// SetTypeDefaultVersionRequest mocks base method.
+func (m *MockCloudFormationAPI) SetTypeDefaultVersionRequest(arg0 *cloudformation.SetTypeDefaultVersionInput) (*request.Request, *cloudformation.SetTypeDefaultVersionOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetTypeDefaultVersionRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.SetTypeDefaultVersionOutput)
+	return ret0, ret1
+}
+
+// SetTypeDefaultVersionRequest indicates an expected call of SetTypeDefaultVersionRequest.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeDefaultVersionRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeDefaultVersionRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeDefaultVersionRequest), arg0)
+}
+
+// SetTypeDefaultVersionWithContext mocks base method.
+func (m *MockCloudFormationAPI) SetTypeDefaultVersionWithContext(arg0 aws.Context, arg1 *cloudformation.SetTypeDefaultVersionInput, arg2 ...request.Option) (*cloudformation.SetTypeDefaultVersionOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetTypeDefaultVersionWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.SetTypeDefaultVersionOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetTypeDefaultVersionWithContext indicates an expected call of SetTypeDefaultVersionWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) SetTypeDefaultVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTypeDefaultVersionWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).SetTypeDefaultVersionWithContext), varargs...)
+}
+
+// SignalResource mocks base method.
+func (m *MockCloudFormationAPI) SignalResource(arg0 *cloudformation.SignalResourceInput) (*cloudformation.SignalResourceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SignalResource", arg0)
+	ret0, _ := ret[0].(*cloudformation.SignalResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SignalResource indicates an expected call of SignalResource.
+func (mr *MockCloudFormationAPIMockRecorder) SignalResource(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalResource", reflect.TypeOf((*MockCloudFormationAPI)(nil).SignalResource), arg0)
+}
+
+// SignalResourceRequest mocks base method.
+func (m *MockCloudFormationAPI) SignalResourceRequest(arg0 *cloudformation.SignalResourceInput) (*request.Request, *cloudformation.SignalResourceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SignalResourceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.SignalResourceOutput)
+	return ret0, ret1
+}
+
+// SignalResourceRequest indicates an expected call of SignalResourceRequest.
+func (mr *MockCloudFormationAPIMockRecorder) SignalResourceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalResourceRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).SignalResourceRequest), arg0)
+}
+
+// SignalResourceWithContext mocks base method.
+func (m *MockCloudFormationAPI) SignalResourceWithContext(arg0 aws.Context, arg1 *cloudformation.SignalResourceInput, arg2 ...request.Option) (*cloudformation.SignalResourceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SignalResourceWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.SignalResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SignalResourceWithContext indicates an expected call of SignalResourceWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) SignalResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalResourceWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).SignalResourceWithContext), varargs...)
+}
+
+// StopStackSetOperation mocks base method.
+func (m *MockCloudFormationAPI) StopStackSetOperation(arg0 *cloudformation.StopStackSetOperationInput) (*cloudformation.StopStackSetOperationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StopStackSetOperation", arg0)
+	ret0, _ := ret[0].(*cloudformation.StopStackSetOperationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StopStackSetOperation indicates an expected call of StopStackSetOperation.
+func (mr *MockCloudFormationAPIMockRecorder) StopStackSetOperation(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStackSetOperation", reflect.TypeOf((*MockCloudFormationAPI)(nil).StopStackSetOperation), arg0)
+}
+
+// StopStackSetOperationRequest mocks base method.
+func (m *MockCloudFormationAPI) StopStackSetOperationRequest(arg0 *cloudformation.StopStackSetOperationInput) (*request.Request, *cloudformation.StopStackSetOperationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StopStackSetOperationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.StopStackSetOperationOutput)
+	return ret0, ret1
+}
+
+// StopStackSetOperationRequest indicates an expected call of StopStackSetOperationRequest.
+func (mr *MockCloudFormationAPIMockRecorder) StopStackSetOperationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStackSetOperationRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).StopStackSetOperationRequest), arg0)
+}
+
+// StopStackSetOperationWithContext mocks base method.
+func (m *MockCloudFormationAPI) StopStackSetOperationWithContext(arg0 aws.Context, arg1 *cloudformation.StopStackSetOperationInput, arg2 ...request.Option) (*cloudformation.StopStackSetOperationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StopStackSetOperationWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.StopStackSetOperationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StopStackSetOperationWithContext indicates an expected call of StopStackSetOperationWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) StopStackSetOperationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStackSetOperationWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).StopStackSetOperationWithContext), varargs...)
+}
+
+// TestType mocks base method.
+func (m *MockCloudFormationAPI) TestType(arg0 *cloudformation.TestTypeInput) (*cloudformation.TestTypeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TestType", arg0)
+	ret0, _ := ret[0].(*cloudformation.TestTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TestType indicates an expected call of TestType.
+func (mr *MockCloudFormationAPIMockRecorder) TestType(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestType", reflect.TypeOf((*MockCloudFormationAPI)(nil).TestType), arg0)
+}
+
+// TestTypeRequest mocks base method.
+func (m *MockCloudFormationAPI) TestTypeRequest(arg0 *cloudformation.TestTypeInput) (*request.Request, *cloudformation.TestTypeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TestTypeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.TestTypeOutput)
+	return ret0, ret1
+}
+
+// TestTypeRequest indicates an expected call of TestTypeRequest.
+func (mr *MockCloudFormationAPIMockRecorder) TestTypeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestTypeRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).TestTypeRequest), arg0)
+}
+
+// TestTypeWithContext mocks base method.
+func (m *MockCloudFormationAPI) TestTypeWithContext(arg0 aws.Context, arg1 *cloudformation.TestTypeInput, arg2 ...request.Option) (*cloudformation.TestTypeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "TestTypeWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.TestTypeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TestTypeWithContext indicates an expected call of TestTypeWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) TestTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).TestTypeWithContext), varargs...)
+}
+
+// UpdateStack mocks base method.
+func (m *MockCloudFormationAPI) UpdateStack(arg0 *cloudformation.UpdateStackInput) (*cloudformation.UpdateStackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStack", arg0)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStack indicates an expected call of UpdateStack.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStack(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStack", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStack), arg0)
+}
+
+// UpdateStackInstances mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackInstances(arg0 *cloudformation.UpdateStackInstancesInput) (*cloudformation.UpdateStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStackInstances", arg0)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStackInstances indicates an expected call of UpdateStackInstances.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackInstances(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackInstances", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackInstances), arg0)
+}
+
+// UpdateStackInstancesRequest mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackInstancesRequest(arg0 *cloudformation.UpdateStackInstancesInput) (*request.Request, *cloudformation.UpdateStackInstancesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStackInstancesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.UpdateStackInstancesOutput)
+	return ret0, ret1
+}
+
+// UpdateStackInstancesRequest indicates an expected call of UpdateStackInstancesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackInstancesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackInstancesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackInstancesRequest), arg0)
+}
+
+// UpdateStackInstancesWithContext mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackInstancesWithContext(arg0 aws.Context, arg1 *cloudformation.UpdateStackInstancesInput, arg2 ...request.Option) (*cloudformation.UpdateStackInstancesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateStackInstancesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackInstancesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStackInstancesWithContext indicates an expected call of UpdateStackInstancesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackInstancesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackInstancesWithContext), varargs...)
+}
+
+// UpdateStackRequest mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackRequest(arg0 *cloudformation.UpdateStackInput) (*request.Request, *cloudformation.UpdateStackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.UpdateStackOutput)
+	return ret0, ret1
+}
+
+// UpdateStackRequest indicates an expected call of UpdateStackRequest.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackRequest), arg0)
+}
+
+// UpdateStackSet mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackSet(arg0 *cloudformation.UpdateStackSetInput) (*cloudformation.UpdateStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStackSet", arg0)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStackSet indicates an expected call of UpdateStackSet.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackSet(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackSet", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackSet), arg0)
+}
+
+// UpdateStackSetRequest mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackSetRequest(arg0 *cloudformation.UpdateStackSetInput) (*request.Request, *cloudformation.UpdateStackSetOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStackSetRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.UpdateStackSetOutput)
+	return ret0, ret1
+}
+
+// UpdateStackSetRequest indicates an expected call of UpdateStackSetRequest.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackSetRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackSetRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackSetRequest), arg0)
+}
+
+// UpdateStackSetWithContext mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackSetWithContext(arg0 aws.Context, arg1 *cloudformation.UpdateStackSetInput, arg2 ...request.Option) (*cloudformation.UpdateStackSetOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateStackSetWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackSetOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStackSetWithContext indicates an expected call of UpdateStackSetWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackSetWithContext), varargs...)
+}
+
+// UpdateStackWithContext mocks base method.
+func (m *MockCloudFormationAPI) UpdateStackWithContext(arg0 aws.Context, arg1 *cloudformation.UpdateStackInput, arg2 ...request.Option) (*cloudformation.UpdateStackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateStackWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.UpdateStackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStackWithContext indicates an expected call of UpdateStackWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateStackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStackWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateStackWithContext), varargs...)
+}
+
+// UpdateTerminationProtection mocks base method.
+func (m *MockCloudFormationAPI) UpdateTerminationProtection(arg0 *cloudformation.UpdateTerminationProtectionInput) (*cloudformation.UpdateTerminationProtectionOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTerminationProtection", arg0)
+	ret0, _ := ret[0].(*cloudformation.UpdateTerminationProtectionOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTerminationProtection indicates an expected call of UpdateTerminationProtection.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateTerminationProtection(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTerminationProtection", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateTerminationProtection), arg0)
+}
+
+// UpdateTerminationProtectionRequest mocks base method.
+func (m *MockCloudFormationAPI) UpdateTerminationProtectionRequest(arg0 *cloudformation.UpdateTerminationProtectionInput) (*request.Request, *cloudformation.UpdateTerminationProtectionOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateTerminationProtectionRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.UpdateTerminationProtectionOutput)
+	return ret0, ret1
+}
+
+// UpdateTerminationProtectionRequest indicates an expected call of UpdateTerminationProtectionRequest.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateTerminationProtectionRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTerminationProtectionRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateTerminationProtectionRequest), arg0)
+}
+
+// UpdateTerminationProtectionWithContext mocks base method.
+func (m *MockCloudFormationAPI) UpdateTerminationProtectionWithContext(arg0 aws.Context, arg1 *cloudformation.UpdateTerminationProtectionInput, arg2 ...request.Option) (*cloudformation.UpdateTerminationProtectionOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateTerminationProtectionWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.UpdateTerminationProtectionOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateTerminationProtectionWithContext indicates an expected call of UpdateTerminationProtectionWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateTerminationProtectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTerminationProtectionWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateTerminationProtectionWithContext), varargs...)
+}
+
+// ValidateTemplate mocks base method.
+func (m *MockCloudFormationAPI) ValidateTemplate(arg0 *cloudformation.ValidateTemplateInput) (*cloudformation.ValidateTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.ValidateTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ValidateTemplate indicates an expected call of ValidateTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) ValidateTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).ValidateTemplate), arg0)
+}
+
+// ValidateTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) ValidateTemplateRequest(arg0 *cloudformation.ValidateTemplateInput) (*request.Request, *cloudformation.ValidateTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ValidateTemplateOutput)
+	return ret0, ret1
+}
+
+// ValidateTemplateRequest indicates an expected call of ValidateTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ValidateTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ValidateTemplateRequest), arg0)
+}
+
+// ValidateTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) ValidateTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.ValidateTemplateInput, arg2 ...request.Option) (*cloudformation.ValidateTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ValidateTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ValidateTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ValidateTemplateWithContext indicates an expected call of ValidateTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ValidateTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ValidateTemplateWithContext), varargs...)
+}
+
+// WaitUntilChangeSetCreateComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilChangeSetCreateComplete(arg0 *cloudformation.DescribeChangeSetInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilChangeSetCreateComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilChangeSetCreateComplete indicates an expected call of WaitUntilChangeSetCreateComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilChangeSetCreateComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilChangeSetCreateComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilChangeSetCreateComplete), arg0)
+}
+
+// WaitUntilChangeSetCreateCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilChangeSetCreateCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeChangeSetInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilChangeSetCreateCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilChangeSetCreateCompleteWithContext indicates an expected call of WaitUntilChangeSetCreateCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilChangeSetCreateCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilChangeSetCreateCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilChangeSetCreateCompleteWithContext), varargs...)
+}
+
+// WaitUntilStackCreateComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackCreateComplete(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackCreateComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackCreateComplete indicates an expected call of WaitUntilStackCreateComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackCreateComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackCreateComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackCreateComplete), arg0)
+}
+
+// WaitUntilStackCreateCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackCreateCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackCreateCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackCreateCompleteWithContext indicates an expected call of WaitUntilStackCreateCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackCreateCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackCreateCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackCreateCompleteWithContext), varargs...)
+}
+
+// WaitUntilStackDeleteComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackDeleteComplete(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackDeleteComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackDeleteComplete indicates an expected call of WaitUntilStackDeleteComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackDeleteComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackDeleteComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackDeleteComplete), arg0)
+}
+
+// WaitUntilStackDeleteCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackDeleteCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackDeleteCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackDeleteCompleteWithContext indicates an expected call of WaitUntilStackDeleteCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackDeleteCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackDeleteCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackDeleteCompleteWithContext), varargs...)
+}
+
+// WaitUntilStackExists mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackExists(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackExists", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackExists indicates an expected call of WaitUntilStackExists.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackExists(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackExists", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackExists), arg0)
+}
+
+// WaitUntilStackExistsWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackExistsWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackExistsWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackExistsWithContext indicates an expected call of WaitUntilStackExistsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackExistsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackExistsWithContext), varargs...)
+}
+
+// WaitUntilStackImportComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackImportComplete(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackImportComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackImportComplete indicates an expected call of WaitUntilStackImportComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackImportComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackImportComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackImportComplete), arg0)
+}
+
+// WaitUntilStackImportCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackImportCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackImportCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackImportCompleteWithContext indicates an expected call of WaitUntilStackImportCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackImportCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackImportCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackImportCompleteWithContext), varargs...)
+}
+
+// WaitUntilStackRollbackComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackRollbackComplete(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackRollbackComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackRollbackComplete indicates an expected call of WaitUntilStackRollbackComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackRollbackComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackRollbackComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackRollbackComplete), arg0)
+}
+
+// WaitUntilStackRollbackCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackRollbackCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackRollbackCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackRollbackCompleteWithContext indicates an expected call of WaitUntilStackRollbackCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackRollbackCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackRollbackCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackRollbackCompleteWithContext), varargs...)
+}
+
+// WaitUntilStackUpdateComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackUpdateComplete(arg0 *cloudformation.DescribeStacksInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilStackUpdateComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackUpdateComplete indicates an expected call of WaitUntilStackUpdateComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackUpdateComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackUpdateComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackUpdateComplete), arg0)
+}
+
+// WaitUntilStackUpdateCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilStackUpdateCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeStacksInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilStackUpdateCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilStackUpdateCompleteWithContext indicates an expected call of WaitUntilStackUpdateCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilStackUpdateCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStackUpdateCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilStackUpdateCompleteWithContext), varargs...)
+}
+
+// WaitUntilTypeRegistrationComplete mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilTypeRegistrationComplete(arg0 *cloudformation.DescribeTypeRegistrationInput) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitUntilTypeRegistrationComplete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilTypeRegistrationComplete indicates an expected call of WaitUntilTypeRegistrationComplete.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilTypeRegistrationComplete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTypeRegistrationComplete", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilTypeRegistrationComplete), arg0)
+}
+
+// WaitUntilTypeRegistrationCompleteWithContext mocks base method.
+func (m *MockCloudFormationAPI) WaitUntilTypeRegistrationCompleteWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeTypeRegistrationInput, arg2 ...request.WaiterOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WaitUntilTypeRegistrationCompleteWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WaitUntilTypeRegistrationCompleteWithContext indicates an expected call of WaitUntilTypeRegistrationCompleteWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) WaitUntilTypeRegistrationCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTypeRegistrationCompleteWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).WaitUntilTypeRegistrationCompleteWithContext), varargs...)
+}