diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
deleted file mode 100644
index a62b68ca9..000000000
--- a/.github/workflows/ci.yaml
+++ /dev/null
@@ -1,93 +0,0 @@
-name: Golang CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    types: [opened, reopened, synchronize]
-  schedule:
-  - cron: '15 3 * * 0'
-  workflow_dispatch:
-
-jobs:
-  build:
-    name: CI Build
-    runs-on: ubuntu-22.04
-    steps:
-    - name: Setup Go
-      uses: actions/setup-go@v5
-      with:
-        go-version: '1.22'
-    - name: Setup tools
-      run: |
-        go install golang.org/x/lint/golint@latest
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Check Formatting
-      run: |
-        if [ "$(gofmt -s -l . | wc -l)" -gt 0 ]; then
-          echo "### Go formatting is off, please execute 'gofmt -w -s .' - see following diff: ###"
-          gofmt -s -d .
-          exit 1
-        fi
-    - name: Test Project
-      run: |
-        make test
-    - name: Build Project
-      run: |
-        make
-
-  docker_build:
-    runs-on: ubuntu-22.04
-    name: Docker Build
-    if: github.event_name != 'pull_request' || (github.event.pull_request.head.repo.full_name == 'rebuy-de/aws-nuke' && github.event.pull_request.user.login != 'dependabot[bot]')
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Generate image tags
-      shell: bash
-      run: |
-        if [ "${GITHUB_EVENT_NAME}" == "pull_request" ]; then
-          BRANCH="$(echo ${GITHUB_HEAD_REF} | tr '/' '_')"
-          echo "tags=quay.io/rebuy/aws-nuke:${BRANCH},docker.io/rebuy/aws-nuke:${BRANCH}" >> $GITHUB_OUTPUT
-        else
-          echo "tags=quay.io/rebuy/aws-nuke:main,docker.io/rebuy/aws-nuke:main,\
-            quay.io/rebuy/aws-nuke:latest,docker.io/rebuy/aws-nuke:latest" >> $GITHUB_OUTPUT
-        fi
-      id: generate_tags
-
-    - name: Set up QEMU
-      if: github.event_name != 'pull_request'
-      id: qemu
-      uses: docker/setup-qemu-action@v3
-      with:
-        platforms: arm64
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-      with:
-        install: true
-
-    - name: Login to Docker Hub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ secrets.DOCKER_USERNAME }}
-        password: ${{ secrets.DOCKER_PASSWORD }}
-
-    - name: Login to Quay.io
-      uses: docker/login-action@v3
-      with:
-        registry: quay.io
-        username: ${{ secrets.QUAY_USERNAME }}
-        password: ${{ secrets.QUAY_PASSWORD }}
-
-    - name: Build and push
-      uses: docker/build-push-action@v5
-      with:
-        context: .
-        push: true
-        tags: ${{ steps.generate_tags.outputs.tags }}
-        platforms: ${{ github.event_name != 'pull_request' && 'linux/amd64,linux/arm64' || 'linux/amd64' }}
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index d48a0f4e8..10b5869bf 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -56,49 +56,3 @@ jobs:
         tag: ${{ github.ref }}
         overwrite: true
         file_glob: true
-
-  docker_build:
-    runs-on: ubuntu-22.04
-    name: Docker Build
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Generate image tags
-      shell: bash
-      run: echo "tags=quay.io/rebuy/aws-nuke:${GITHUB_REF#refs/tags/},docker.io/rebuy/aws-nuke:${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-      id: generate_tags
-
-    - name: Set up QEMU
-      id: qemu
-      uses: docker/setup-qemu-action@v3
-      with:
-        platforms: arm64
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-      with:
-        install: true
-
-    - name: Login to Docker Hub
-      uses: docker/login-action@v3
-      with:
-        username: ${{ secrets.DOCKER_USERNAME }}
-        password: ${{ secrets.DOCKER_PASSWORD }}
-
-    - name: Login to Quay.io
-      uses: docker/login-action@v3
-      with:
-        registry: quay.io
-        username: ${{ secrets.QUAY_USERNAME }}
-        password: ${{ secrets.QUAY_PASSWORD }}
-
-    - name: Build and push
-      uses: docker/build-push-action@v5
-      with:
-        context: .
-        push: true
-        tags: ${{ steps.generate_tags.outputs.tags }}
-        platforms: linux/amd64,linux/arm64
diff --git a/cmd/nuke.go b/cmd/nuke.go
index 8cbfe6369..093a7e608 100644
--- a/cmd/nuke.go
+++ b/cmd/nuke.go
@@ -160,7 +160,11 @@ func (n *Nuke) Scan() error {
 	queue := make(Queue, 0)
 
 	for _, regionName := range n.Config.Regions {
-		region := NewRegion(regionName, n.Account.ResourceTypeToServiceType, n.Account.NewSession)
+		config, err := n.Account.Credentials.NewConfig(regionName)
+		if err != nil {
+			return err
+		}
+		region := NewRegion(regionName, config, n.Account.ResourceTypeToServiceType, n.Account.NewSession)
 
 		items := Scan(region, resourceTypes)
 		for item := range items {
diff --git a/cmd/queue.go b/cmd/queue.go
index cc6189ac9..01947ffb3 100644
--- a/cmd/queue.go
+++ b/cmd/queue.go
@@ -53,6 +53,12 @@ func (i *Item) Print() {
 // List gets all resource items of the same resource type like the Item.
 func (i *Item) List() ([]resources.Resource, error) {
 	lister := resources.GetLister(i.Type)
+	if lister == nil {
+		// Type has supported V2 implementation
+		lister := resources.GetListerV2(i.Type)
+		return lister(i.Region.Config)
+	}
+
 	sess, err := i.Region.Session(i.Type)
 	if err != nil {
 		return nil, err
diff --git a/cmd/region.go b/cmd/region.go
index adf5f58dc..43adf6b5b 100644
--- a/cmd/region.go
+++ b/cmd/region.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"sync"
 
+	"github.com/aws/aws-sdk-go-v2/aws"
+
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/rebuy-de/aws-nuke/v2/pkg/awsutil"
 )
@@ -19,14 +21,17 @@ type Region struct {
 	NewSession      SessionFactory
 	ResTypeResolver ResourceTypeResolver
 
+	Config *aws.Config
+
 	cache map[string]*session.Session
 	lock  *sync.RWMutex
 }
 
-func NewRegion(name string, typeResolver ResourceTypeResolver, sessionFactory SessionFactory) *Region {
+func NewRegion(name string, config *aws.Config, typeResolver ResourceTypeResolver, sessionFactory SessionFactory) *Region {
 	return &Region{
 		Name:            name,
 		NewSession:      sessionFactory,
+		Config:          config,
 		ResTypeResolver: typeResolver,
 		lock:            &sync.RWMutex{},
 		cache:           make(map[string]*session.Session),
@@ -60,3 +65,13 @@ func (region *Region) Session(resourceType string) (*session.Session, error) {
 	region.lock.Unlock()
 	return sess, nil
 }
+
+func (region *Region) NewConfig(resourceType string) (*aws.Config, error) {
+	if region.Name == "global" {
+		return nil, awsutil.ErrSkipRequest(fmt.Sprintf(
+			"No service available in region '%s' to handle '%s'",
+			region.Name, resourceType))
+	}
+
+	return region.Config, nil
+}
diff --git a/cmd/scan.go b/cmd/scan.go
index aa03f51ee..576c95ae4 100644
--- a/cmd/scan.go
+++ b/cmd/scan.go
@@ -56,7 +56,7 @@ func (s *scanner) list(region *Region, resourceType string) {
 	lister := resources.GetLister(resourceType)
 	var rs []resources.Resource
 	sess, err := region.Session(resourceType)
-	if err == nil {
+	if err == nil && lister != nil {
 		rs, err = lister(sess)
 	}
 	if err != nil {
@@ -77,6 +77,32 @@ func (s *scanner) list(region *Region, resourceType string) {
 		return
 	}
 
+	listerV2 := resources.GetListerV2(resourceType)
+	var rsV2 []resources.Resource
+	cfg, err := region.NewConfig(resourceType)
+	if err == nil && listerV2 != nil {
+		rsV2, err = listerV2(cfg)
+	}
+	if err != nil {
+		_, ok := err.(awsutil.ErrSkipRequest)
+		if ok {
+			log.Debugf("skipping request: %v", err)
+			return
+		}
+
+		_, ok = err.(awsutil.ErrUnknownEndpoint)
+		if ok {
+			log.Warnf("skipping request: %v", err)
+			return
+		}
+
+		dump := util.Indent(fmt.Sprintf("%v", err), "    ")
+		log.Errorf("Listing %s failed:\n%s", resourceType, dump)
+		return
+	}
+
+	rs = append(rs, rsV2...)
+
 	for _, r := range rs {
 		s.items <- &Item{
 			Region:   region,
diff --git a/go.mod b/go.mod
index 2664a0f51..0e3138a1e 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,11 @@ go 1.21
 
 require (
 	github.com/aws/aws-sdk-go v1.53.15
+	github.com/aws/aws-sdk-go-v2 v1.30.0
+	github.com/aws/aws-sdk-go-v2/config v1.27.22
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.22
+	github.com/aws/aws-sdk-go-v2/service/networkfirewall v1.40.0
+	github.com/aws/aws-sdk-go-v2/service/sts v1.30.0
 	github.com/fatih/color v1.17.0
 	github.com/golang/mock v1.6.0
 	github.com/google/uuid v1.6.0
@@ -18,6 +23,15 @@ require (
 )
 
 require (
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.8 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.12 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.12 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.14 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.22.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.0 // indirect
+	github.com/aws/smithy-go v1.20.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/gemnasium/logrus-graylog-hook/v3 v3.1.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
diff --git a/go.sum b/go.sum
index 490f52452..9a0dcb15a 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,33 @@
 github.com/aws/aws-sdk-go v1.53.15 h1:FtZmkg7xM8RfP2oY6p7xdKBYrRgkITk9yve2QV7N938=
 github.com/aws/aws-sdk-go v1.53.15/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk=
+github.com/aws/aws-sdk-go-v2 v1.30.0 h1:6qAwtzlfcTtcL8NHtbDQAqgM5s6NDipQTkPxyH/6kAA=
+github.com/aws/aws-sdk-go-v2 v1.30.0/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM=
+github.com/aws/aws-sdk-go-v2/config v1.27.22 h1:TRkQVtpDINt+Na/ToU7iptyW6U0awAwJ24q4XN+59k8=
+github.com/aws/aws-sdk-go-v2/config v1.27.22/go.mod h1:EYY3mVgFRUWkh6QNKH64MdyKs1YSUgatc0Zp3MDxi7c=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.22 h1:wu9kXQbbt64ul09v3ye4HYleAr4WiGV/uv69EXKDEr0=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.22/go.mod h1:pcvMtPcxJn3r2k6mZD9I0EcumLqPLA7V/0iCgOIlY+o=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.8 h1:FR+oWPFb/8qMVYMWN98bUZAGqPvLHiyqg1wqQGfUAXY=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.8/go.mod h1:EgSKcHiuuakEIxJcKGzVNWh5srVAQ3jKaSrBGRYvM48=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.12 h1:SJ04WXGTwnHlWIODtC5kJzKbeuHt+OUNOgKg7nfnUGw=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.12/go.mod h1:FkpvXhA92gb3GE9LD6Og0pHHycTxW7xGpnEh5E7Opwo=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.12 h1:hb5KgeYfObi5MHkSSZMEudnIvX30iB+E21evI4r6BnQ=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.12/go.mod h1:CroKe/eWJdyfy9Vx4rljP5wTUjNJfb+fPz1uMYUhEGM=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 h1:Ji0DY1xUsUr3I8cHps0G+XM3WWU16lP6yG8qu1GAZAs=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2/go.mod h1:5CsjAbs3NlGQyZNFACh+zztPDI7fU6eW9QsxjfnuBKg=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.14 h1:zSDPny/pVnkqABXYRicYuPf9z2bTqfH13HT3v6UheIk=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.14/go.mod h1:3TTcI5JSzda1nw/pkVC9dhgLre0SNBFj2lYS4GctXKI=
+github.com/aws/aws-sdk-go-v2/service/networkfirewall v1.40.0 h1:ZKjJJWxZ4cGM6LWxXsnviGlBpqPvifSod4U8gOXik9U=
+github.com/aws/aws-sdk-go-v2/service/networkfirewall v1.40.0/go.mod h1:23qyfghRkv9qOMRIL9KdUHiKyhARU/0FddRMtvMSVV0=
+github.com/aws/aws-sdk-go-v2/service/sso v1.22.0 h1:lPIAPCRoJkmotLTU/9B6icUFlYDpEuWjKeL79XROv1M=
+github.com/aws/aws-sdk-go-v2/service/sso v1.22.0/go.mod h1:lcQG/MmxydijbeTOp04hIuJwXGWPZGI3bwdFDGRTv14=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.0 h1:/4r71ghx+hX9spr884cqXHPEmPzqH/J3K7fkE1yfcmw=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.0/go.mod h1:z0P8K+cBIsFXUr5rzo/psUeJ20XjPN0+Nn8067Nd+E4=
+github.com/aws/aws-sdk-go-v2/service/sts v1.30.0 h1:9ja34PaKybhCJjVKvxtDsUjbATUJGN+eF6QnO58u5cI=
+github.com/aws/aws-sdk-go-v2/service/sts v1.30.0/go.mod h1:N2mQiucsO0VwK9CYuS4/c2n6Smeh1v47Rz3dWCPFLdE=
+github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q=
+github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
diff --git a/mocks/mock_cloudformationiface/mock.go b/mocks/mock_cloudformationiface/mock.go
index dd6a0fbe6..88de98b0b 100644
--- a/mocks/mock_cloudformationiface/mock.go
+++ b/mocks/mock_cloudformationiface/mock.go
@@ -1,5 +1,5 @@
 // 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
+// Source: /Users/bfisher8/go/pkg/mod/github.com/aws/aws-sdk-go@v1.53.15/service/cloudformation/cloudformationiface/interface.go
 
 // Package mock_cloudformationiface is a generated GoMock package.
 package mock_cloudformationiface
@@ -336,6 +336,56 @@ func (mr *MockCloudFormationAPIMockRecorder) CreateChangeSetWithContext(arg0, ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateChangeSetWithContext), varargs...)
 }
 
+// CreateGeneratedTemplate mocks base method.
+func (m *MockCloudFormationAPI) CreateGeneratedTemplate(arg0 *cloudformation.CreateGeneratedTemplateInput) (*cloudformation.CreateGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGeneratedTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.CreateGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateGeneratedTemplate indicates an expected call of CreateGeneratedTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) CreateGeneratedTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGeneratedTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateGeneratedTemplate), arg0)
+}
+
+// CreateGeneratedTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) CreateGeneratedTemplateRequest(arg0 *cloudformation.CreateGeneratedTemplateInput) (*request.Request, *cloudformation.CreateGeneratedTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGeneratedTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.CreateGeneratedTemplateOutput)
+	return ret0, ret1
+}
+
+// CreateGeneratedTemplateRequest indicates an expected call of CreateGeneratedTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) CreateGeneratedTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGeneratedTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateGeneratedTemplateRequest), arg0)
+}
+
+// CreateGeneratedTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) CreateGeneratedTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.CreateGeneratedTemplateInput, arg2 ...request.Option) (*cloudformation.CreateGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateGeneratedTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.CreateGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateGeneratedTemplateWithContext indicates an expected call of CreateGeneratedTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) CreateGeneratedTemplateWithContext(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, "CreateGeneratedTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).CreateGeneratedTemplateWithContext), varargs...)
+}
+
 // CreateStack mocks base method.
 func (m *MockCloudFormationAPI) CreateStack(arg0 *cloudformation.CreateStackInput) (*cloudformation.CreateStackOutput, error) {
 	m.ctrl.T.Helper()
@@ -636,6 +686,56 @@ func (mr *MockCloudFormationAPIMockRecorder) DeleteChangeSetWithContext(arg0, ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteChangeSetWithContext), varargs...)
 }
 
+// DeleteGeneratedTemplate mocks base method.
+func (m *MockCloudFormationAPI) DeleteGeneratedTemplate(arg0 *cloudformation.DeleteGeneratedTemplateInput) (*cloudformation.DeleteGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGeneratedTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.DeleteGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteGeneratedTemplate indicates an expected call of DeleteGeneratedTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteGeneratedTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGeneratedTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteGeneratedTemplate), arg0)
+}
+
+// DeleteGeneratedTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) DeleteGeneratedTemplateRequest(arg0 *cloudformation.DeleteGeneratedTemplateInput) (*request.Request, *cloudformation.DeleteGeneratedTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGeneratedTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DeleteGeneratedTemplateOutput)
+	return ret0, ret1
+}
+
+// DeleteGeneratedTemplateRequest indicates an expected call of DeleteGeneratedTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteGeneratedTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGeneratedTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteGeneratedTemplateRequest), arg0)
+}
+
+// DeleteGeneratedTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) DeleteGeneratedTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.DeleteGeneratedTemplateInput, arg2 ...request.Option) (*cloudformation.DeleteGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteGeneratedTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DeleteGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteGeneratedTemplateWithContext indicates an expected call of DeleteGeneratedTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DeleteGeneratedTemplateWithContext(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, "DeleteGeneratedTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DeleteGeneratedTemplateWithContext), varargs...)
+}
+
 // DeleteStack mocks base method.
 func (m *MockCloudFormationAPI) DeleteStack(arg0 *cloudformation.DeleteStackInput) (*cloudformation.DeleteStackOutput, error) {
 	m.ctrl.T.Helper()
@@ -1019,6 +1119,56 @@ func (mr *MockCloudFormationAPIMockRecorder) DescribeChangeSetWithContext(arg0,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeChangeSetWithContext), varargs...)
 }
 
+// DescribeGeneratedTemplate mocks base method.
+func (m *MockCloudFormationAPI) DescribeGeneratedTemplate(arg0 *cloudformation.DescribeGeneratedTemplateInput) (*cloudformation.DescribeGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeGeneratedTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeGeneratedTemplate indicates an expected call of DescribeGeneratedTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeGeneratedTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGeneratedTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeGeneratedTemplate), arg0)
+}
+
+// DescribeGeneratedTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeGeneratedTemplateRequest(arg0 *cloudformation.DescribeGeneratedTemplateInput) (*request.Request, *cloudformation.DescribeGeneratedTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeGeneratedTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeGeneratedTemplateOutput)
+	return ret0, ret1
+}
+
+// DescribeGeneratedTemplateRequest indicates an expected call of DescribeGeneratedTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeGeneratedTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGeneratedTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeGeneratedTemplateRequest), arg0)
+}
+
+// DescribeGeneratedTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeGeneratedTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeGeneratedTemplateInput, arg2 ...request.Option) (*cloudformation.DescribeGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeGeneratedTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeGeneratedTemplateWithContext indicates an expected call of DescribeGeneratedTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeGeneratedTemplateWithContext(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, "DescribeGeneratedTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeGeneratedTemplateWithContext), varargs...)
+}
+
 // DescribeOrganizationsAccess mocks base method.
 func (m *MockCloudFormationAPI) DescribeOrganizationsAccess(arg0 *cloudformation.DescribeOrganizationsAccessInput) (*cloudformation.DescribeOrganizationsAccessOutput, error) {
 	m.ctrl.T.Helper()
@@ -1119,6 +1269,56 @@ func (mr *MockCloudFormationAPIMockRecorder) DescribePublisherWithContext(arg0,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublisherWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribePublisherWithContext), varargs...)
 }
 
+// DescribeResourceScan mocks base method.
+func (m *MockCloudFormationAPI) DescribeResourceScan(arg0 *cloudformation.DescribeResourceScanInput) (*cloudformation.DescribeResourceScanOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeResourceScan", arg0)
+	ret0, _ := ret[0].(*cloudformation.DescribeResourceScanOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeResourceScan indicates an expected call of DescribeResourceScan.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeResourceScan(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceScan", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeResourceScan), arg0)
+}
+
+// DescribeResourceScanRequest mocks base method.
+func (m *MockCloudFormationAPI) DescribeResourceScanRequest(arg0 *cloudformation.DescribeResourceScanInput) (*request.Request, *cloudformation.DescribeResourceScanOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeResourceScanRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.DescribeResourceScanOutput)
+	return ret0, ret1
+}
+
+// DescribeResourceScanRequest indicates an expected call of DescribeResourceScanRequest.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeResourceScanRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceScanRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeResourceScanRequest), arg0)
+}
+
+// DescribeResourceScanWithContext mocks base method.
+func (m *MockCloudFormationAPI) DescribeResourceScanWithContext(arg0 aws.Context, arg1 *cloudformation.DescribeResourceScanInput, arg2 ...request.Option) (*cloudformation.DescribeResourceScanOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeResourceScanWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.DescribeResourceScanOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeResourceScanWithContext indicates an expected call of DescribeResourceScanWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) DescribeResourceScanWithContext(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, "DescribeResourceScanWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).DescribeResourceScanWithContext), varargs...)
+}
+
 // DescribeStackDriftDetectionStatus mocks base method.
 func (m *MockCloudFormationAPI) DescribeStackDriftDetectionStatus(arg0 *cloudformation.DescribeStackDriftDetectionStatusInput) (*cloudformation.DescribeStackDriftDetectionStatusOutput, error) {
 	m.ctrl.T.Helper()
@@ -2018,6 +2218,56 @@ func (mr *MockCloudFormationAPIMockRecorder) ExecuteChangeSetWithContext(arg0, a
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteChangeSetWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ExecuteChangeSetWithContext), varargs...)
 }
 
+// GetGeneratedTemplate mocks base method.
+func (m *MockCloudFormationAPI) GetGeneratedTemplate(arg0 *cloudformation.GetGeneratedTemplateInput) (*cloudformation.GetGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetGeneratedTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.GetGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGeneratedTemplate indicates an expected call of GetGeneratedTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) GetGeneratedTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeneratedTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetGeneratedTemplate), arg0)
+}
+
+// GetGeneratedTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) GetGeneratedTemplateRequest(arg0 *cloudformation.GetGeneratedTemplateInput) (*request.Request, *cloudformation.GetGeneratedTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetGeneratedTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.GetGeneratedTemplateOutput)
+	return ret0, ret1
+}
+
+// GetGeneratedTemplateRequest indicates an expected call of GetGeneratedTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) GetGeneratedTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeneratedTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetGeneratedTemplateRequest), arg0)
+}
+
+// GetGeneratedTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) GetGeneratedTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.GetGeneratedTemplateInput, arg2 ...request.Option) (*cloudformation.GetGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGeneratedTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.GetGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGeneratedTemplateWithContext indicates an expected call of GetGeneratedTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) GetGeneratedTemplateWithContext(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, "GetGeneratedTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).GetGeneratedTemplateWithContext), varargs...)
+}
+
 // GetStackPolicy mocks base method.
 func (m *MockCloudFormationAPI) GetStackPolicy(arg0 *cloudformation.GetStackPolicyInput) (*cloudformation.GetStackPolicyOutput, error) {
 	m.ctrl.T.Helper()
@@ -2384,6 +2634,89 @@ func (mr *MockCloudFormationAPIMockRecorder) ListExportsWithContext(arg0, arg1 i
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListExportsWithContext), varargs...)
 }
 
+// ListGeneratedTemplates mocks base method.
+func (m *MockCloudFormationAPI) ListGeneratedTemplates(arg0 *cloudformation.ListGeneratedTemplatesInput) (*cloudformation.ListGeneratedTemplatesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGeneratedTemplates", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListGeneratedTemplatesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListGeneratedTemplates indicates an expected call of ListGeneratedTemplates.
+func (mr *MockCloudFormationAPIMockRecorder) ListGeneratedTemplates(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeneratedTemplates", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListGeneratedTemplates), arg0)
+}
+
+// ListGeneratedTemplatesPages mocks base method.
+func (m *MockCloudFormationAPI) ListGeneratedTemplatesPages(arg0 *cloudformation.ListGeneratedTemplatesInput, arg1 func(*cloudformation.ListGeneratedTemplatesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGeneratedTemplatesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListGeneratedTemplatesPages indicates an expected call of ListGeneratedTemplatesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListGeneratedTemplatesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeneratedTemplatesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListGeneratedTemplatesPages), arg0, arg1)
+}
+
+// ListGeneratedTemplatesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListGeneratedTemplatesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListGeneratedTemplatesInput, arg2 func(*cloudformation.ListGeneratedTemplatesOutput, 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, "ListGeneratedTemplatesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListGeneratedTemplatesPagesWithContext indicates an expected call of ListGeneratedTemplatesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListGeneratedTemplatesPagesWithContext(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, "ListGeneratedTemplatesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListGeneratedTemplatesPagesWithContext), varargs...)
+}
+
+// ListGeneratedTemplatesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListGeneratedTemplatesRequest(arg0 *cloudformation.ListGeneratedTemplatesInput) (*request.Request, *cloudformation.ListGeneratedTemplatesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGeneratedTemplatesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListGeneratedTemplatesOutput)
+	return ret0, ret1
+}
+
+// ListGeneratedTemplatesRequest indicates an expected call of ListGeneratedTemplatesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListGeneratedTemplatesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeneratedTemplatesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListGeneratedTemplatesRequest), arg0)
+}
+
+// ListGeneratedTemplatesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListGeneratedTemplatesWithContext(arg0 aws.Context, arg1 *cloudformation.ListGeneratedTemplatesInput, arg2 ...request.Option) (*cloudformation.ListGeneratedTemplatesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListGeneratedTemplatesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListGeneratedTemplatesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListGeneratedTemplatesWithContext indicates an expected call of ListGeneratedTemplatesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListGeneratedTemplatesWithContext(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, "ListGeneratedTemplatesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListGeneratedTemplatesWithContext), varargs...)
+}
+
 // ListImports mocks base method.
 func (m *MockCloudFormationAPI) ListImports(arg0 *cloudformation.ListImportsInput) (*cloudformation.ListImportsOutput, error) {
 	m.ctrl.T.Helper()
@@ -2467,6 +2800,255 @@ func (mr *MockCloudFormationAPIMockRecorder) ListImportsWithContext(arg0, arg1 i
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListImportsWithContext), varargs...)
 }
 
+// ListResourceScanRelatedResources mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanRelatedResources(arg0 *cloudformation.ListResourceScanRelatedResourcesInput) (*cloudformation.ListResourceScanRelatedResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanRelatedResources", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScanRelatedResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScanRelatedResources indicates an expected call of ListResourceScanRelatedResources.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanRelatedResources(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanRelatedResources", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanRelatedResources), arg0)
+}
+
+// ListResourceScanRelatedResourcesPages mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanRelatedResourcesPages(arg0 *cloudformation.ListResourceScanRelatedResourcesInput, arg1 func(*cloudformation.ListResourceScanRelatedResourcesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanRelatedResourcesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScanRelatedResourcesPages indicates an expected call of ListResourceScanRelatedResourcesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanRelatedResourcesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanRelatedResourcesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanRelatedResourcesPages), arg0, arg1)
+}
+
+// ListResourceScanRelatedResourcesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanRelatedResourcesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScanRelatedResourcesInput, arg2 func(*cloudformation.ListResourceScanRelatedResourcesOutput, 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, "ListResourceScanRelatedResourcesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScanRelatedResourcesPagesWithContext indicates an expected call of ListResourceScanRelatedResourcesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanRelatedResourcesPagesWithContext(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, "ListResourceScanRelatedResourcesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanRelatedResourcesPagesWithContext), varargs...)
+}
+
+// ListResourceScanRelatedResourcesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanRelatedResourcesRequest(arg0 *cloudformation.ListResourceScanRelatedResourcesInput) (*request.Request, *cloudformation.ListResourceScanRelatedResourcesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanRelatedResourcesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListResourceScanRelatedResourcesOutput)
+	return ret0, ret1
+}
+
+// ListResourceScanRelatedResourcesRequest indicates an expected call of ListResourceScanRelatedResourcesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanRelatedResourcesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanRelatedResourcesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanRelatedResourcesRequest), arg0)
+}
+
+// ListResourceScanRelatedResourcesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanRelatedResourcesWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScanRelatedResourcesInput, arg2 ...request.Option) (*cloudformation.ListResourceScanRelatedResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListResourceScanRelatedResourcesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScanRelatedResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScanRelatedResourcesWithContext indicates an expected call of ListResourceScanRelatedResourcesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanRelatedResourcesWithContext(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, "ListResourceScanRelatedResourcesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanRelatedResourcesWithContext), varargs...)
+}
+
+// ListResourceScanResources mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanResources(arg0 *cloudformation.ListResourceScanResourcesInput) (*cloudformation.ListResourceScanResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanResources", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScanResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScanResources indicates an expected call of ListResourceScanResources.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanResources(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanResources", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanResources), arg0)
+}
+
+// ListResourceScanResourcesPages mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanResourcesPages(arg0 *cloudformation.ListResourceScanResourcesInput, arg1 func(*cloudformation.ListResourceScanResourcesOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanResourcesPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScanResourcesPages indicates an expected call of ListResourceScanResourcesPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanResourcesPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanResourcesPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanResourcesPages), arg0, arg1)
+}
+
+// ListResourceScanResourcesPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanResourcesPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScanResourcesInput, arg2 func(*cloudformation.ListResourceScanResourcesOutput, 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, "ListResourceScanResourcesPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScanResourcesPagesWithContext indicates an expected call of ListResourceScanResourcesPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanResourcesPagesWithContext(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, "ListResourceScanResourcesPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanResourcesPagesWithContext), varargs...)
+}
+
+// ListResourceScanResourcesRequest mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanResourcesRequest(arg0 *cloudformation.ListResourceScanResourcesInput) (*request.Request, *cloudformation.ListResourceScanResourcesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScanResourcesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListResourceScanResourcesOutput)
+	return ret0, ret1
+}
+
+// ListResourceScanResourcesRequest indicates an expected call of ListResourceScanResourcesRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanResourcesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScanResourcesRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanResourcesRequest), arg0)
+}
+
+// ListResourceScanResourcesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScanResourcesWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScanResourcesInput, arg2 ...request.Option) (*cloudformation.ListResourceScanResourcesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListResourceScanResourcesWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScanResourcesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScanResourcesWithContext indicates an expected call of ListResourceScanResourcesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScanResourcesWithContext(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, "ListResourceScanResourcesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScanResourcesWithContext), varargs...)
+}
+
+// ListResourceScans mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScans(arg0 *cloudformation.ListResourceScansInput) (*cloudformation.ListResourceScansOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScans", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScansOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScans indicates an expected call of ListResourceScans.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScans(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScans", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScans), arg0)
+}
+
+// ListResourceScansPages mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScansPages(arg0 *cloudformation.ListResourceScansInput, arg1 func(*cloudformation.ListResourceScansOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScansPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScansPages indicates an expected call of ListResourceScansPages.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScansPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScansPages", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScansPages), arg0, arg1)
+}
+
+// ListResourceScansPagesWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScansPagesWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScansInput, arg2 func(*cloudformation.ListResourceScansOutput, 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, "ListResourceScansPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceScansPagesWithContext indicates an expected call of ListResourceScansPagesWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScansPagesWithContext(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, "ListResourceScansPagesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScansPagesWithContext), varargs...)
+}
+
+// ListResourceScansRequest mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScansRequest(arg0 *cloudformation.ListResourceScansInput) (*request.Request, *cloudformation.ListResourceScansOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceScansRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListResourceScansOutput)
+	return ret0, ret1
+}
+
+// ListResourceScansRequest indicates an expected call of ListResourceScansRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScansRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceScansRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScansRequest), arg0)
+}
+
+// ListResourceScansWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListResourceScansWithContext(arg0 aws.Context, arg1 *cloudformation.ListResourceScansInput, arg2 ...request.Option) (*cloudformation.ListResourceScansOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListResourceScansWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListResourceScansOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceScansWithContext indicates an expected call of ListResourceScansWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListResourceScansWithContext(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, "ListResourceScansWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListResourceScansWithContext), varargs...)
+}
+
 // ListStackInstanceResourceDrifts mocks base method.
 func (m *MockCloudFormationAPI) ListStackInstanceResourceDrifts(arg0 *cloudformation.ListStackInstanceResourceDriftsInput) (*cloudformation.ListStackInstanceResourceDriftsOutput, error) {
 	m.ctrl.T.Helper()
@@ -2683,6 +3265,56 @@ func (mr *MockCloudFormationAPIMockRecorder) ListStackResourcesWithContext(arg0,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackResourcesWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackResourcesWithContext), varargs...)
 }
 
+// ListStackSetAutoDeploymentTargets mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetAutoDeploymentTargets(arg0 *cloudformation.ListStackSetAutoDeploymentTargetsInput) (*cloudformation.ListStackSetAutoDeploymentTargetsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetAutoDeploymentTargets", arg0)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetAutoDeploymentTargetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetAutoDeploymentTargets indicates an expected call of ListStackSetAutoDeploymentTargets.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetAutoDeploymentTargets(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetAutoDeploymentTargets", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetAutoDeploymentTargets), arg0)
+}
+
+// ListStackSetAutoDeploymentTargetsRequest mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetAutoDeploymentTargetsRequest(arg0 *cloudformation.ListStackSetAutoDeploymentTargetsInput) (*request.Request, *cloudformation.ListStackSetAutoDeploymentTargetsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListStackSetAutoDeploymentTargetsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.ListStackSetAutoDeploymentTargetsOutput)
+	return ret0, ret1
+}
+
+// ListStackSetAutoDeploymentTargetsRequest indicates an expected call of ListStackSetAutoDeploymentTargetsRequest.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetAutoDeploymentTargetsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStackSetAutoDeploymentTargetsRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetAutoDeploymentTargetsRequest), arg0)
+}
+
+// ListStackSetAutoDeploymentTargetsWithContext mocks base method.
+func (m *MockCloudFormationAPI) ListStackSetAutoDeploymentTargetsWithContext(arg0 aws.Context, arg1 *cloudformation.ListStackSetAutoDeploymentTargetsInput, arg2 ...request.Option) (*cloudformation.ListStackSetAutoDeploymentTargetsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListStackSetAutoDeploymentTargetsWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.ListStackSetAutoDeploymentTargetsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListStackSetAutoDeploymentTargetsWithContext indicates an expected call of ListStackSetAutoDeploymentTargetsWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) ListStackSetAutoDeploymentTargetsWithContext(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, "ListStackSetAutoDeploymentTargetsWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).ListStackSetAutoDeploymentTargetsWithContext), varargs...)
+}
+
 // ListStackSetOperationResults mocks base method.
 func (m *MockCloudFormationAPI) ListStackSetOperationResults(arg0 *cloudformation.ListStackSetOperationResultsInput) (*cloudformation.ListStackSetOperationResultsOutput, error) {
 	m.ctrl.T.Helper()
@@ -3714,6 +4346,56 @@ func (mr *MockCloudFormationAPIMockRecorder) SignalResourceWithContext(arg0, arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignalResourceWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).SignalResourceWithContext), varargs...)
 }
 
+// StartResourceScan mocks base method.
+func (m *MockCloudFormationAPI) StartResourceScan(arg0 *cloudformation.StartResourceScanInput) (*cloudformation.StartResourceScanOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartResourceScan", arg0)
+	ret0, _ := ret[0].(*cloudformation.StartResourceScanOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartResourceScan indicates an expected call of StartResourceScan.
+func (mr *MockCloudFormationAPIMockRecorder) StartResourceScan(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartResourceScan", reflect.TypeOf((*MockCloudFormationAPI)(nil).StartResourceScan), arg0)
+}
+
+// StartResourceScanRequest mocks base method.
+func (m *MockCloudFormationAPI) StartResourceScanRequest(arg0 *cloudformation.StartResourceScanInput) (*request.Request, *cloudformation.StartResourceScanOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartResourceScanRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.StartResourceScanOutput)
+	return ret0, ret1
+}
+
+// StartResourceScanRequest indicates an expected call of StartResourceScanRequest.
+func (mr *MockCloudFormationAPIMockRecorder) StartResourceScanRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartResourceScanRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).StartResourceScanRequest), arg0)
+}
+
+// StartResourceScanWithContext mocks base method.
+func (m *MockCloudFormationAPI) StartResourceScanWithContext(arg0 aws.Context, arg1 *cloudformation.StartResourceScanInput, arg2 ...request.Option) (*cloudformation.StartResourceScanOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StartResourceScanWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.StartResourceScanOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartResourceScanWithContext indicates an expected call of StartResourceScanWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) StartResourceScanWithContext(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, "StartResourceScanWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).StartResourceScanWithContext), varargs...)
+}
+
 // StopStackSetOperation mocks base method.
 func (m *MockCloudFormationAPI) StopStackSetOperation(arg0 *cloudformation.StopStackSetOperationInput) (*cloudformation.StopStackSetOperationOutput, error) {
 	m.ctrl.T.Helper()
@@ -3814,6 +4496,56 @@ func (mr *MockCloudFormationAPIMockRecorder) TestTypeWithContext(arg0, arg1 inte
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestTypeWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).TestTypeWithContext), varargs...)
 }
 
+// UpdateGeneratedTemplate mocks base method.
+func (m *MockCloudFormationAPI) UpdateGeneratedTemplate(arg0 *cloudformation.UpdateGeneratedTemplateInput) (*cloudformation.UpdateGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateGeneratedTemplate", arg0)
+	ret0, _ := ret[0].(*cloudformation.UpdateGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateGeneratedTemplate indicates an expected call of UpdateGeneratedTemplate.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateGeneratedTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGeneratedTemplate", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateGeneratedTemplate), arg0)
+}
+
+// UpdateGeneratedTemplateRequest mocks base method.
+func (m *MockCloudFormationAPI) UpdateGeneratedTemplateRequest(arg0 *cloudformation.UpdateGeneratedTemplateInput) (*request.Request, *cloudformation.UpdateGeneratedTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateGeneratedTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cloudformation.UpdateGeneratedTemplateOutput)
+	return ret0, ret1
+}
+
+// UpdateGeneratedTemplateRequest indicates an expected call of UpdateGeneratedTemplateRequest.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateGeneratedTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGeneratedTemplateRequest", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateGeneratedTemplateRequest), arg0)
+}
+
+// UpdateGeneratedTemplateWithContext mocks base method.
+func (m *MockCloudFormationAPI) UpdateGeneratedTemplateWithContext(arg0 aws.Context, arg1 *cloudformation.UpdateGeneratedTemplateInput, arg2 ...request.Option) (*cloudformation.UpdateGeneratedTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateGeneratedTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*cloudformation.UpdateGeneratedTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateGeneratedTemplateWithContext indicates an expected call of UpdateGeneratedTemplateWithContext.
+func (mr *MockCloudFormationAPIMockRecorder) UpdateGeneratedTemplateWithContext(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, "UpdateGeneratedTemplateWithContext", reflect.TypeOf((*MockCloudFormationAPI)(nil).UpdateGeneratedTemplateWithContext), varargs...)
+}
+
 // UpdateStack mocks base method.
 func (m *MockCloudFormationAPI) UpdateStack(arg0 *cloudformation.UpdateStackInput) (*cloudformation.UpdateStackOutput, error) {
 	m.ctrl.T.Helper()
diff --git a/pkg/awsutil/config.go b/pkg/awsutil/config.go
new file mode 100644
index 000000000..e85f13572
--- /dev/null
+++ b/pkg/awsutil/config.go
@@ -0,0 +1,68 @@
+package awsutil
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/credentials/stscreds"
+	"github.com/aws/aws-sdk-go-v2/service/sts"
+)
+
+func (c *Credentials) NewConfig(region string) (*aws.Config, error) {
+	if c.config == nil {
+		if c.HasProfile() && c.HasKeys() {
+			return nil, fmt.Errorf("you have to specify a profile or credentials for at least one region")
+		}
+
+		if c.HasKeys() {
+			cfg, err := config.LoadDefaultConfig(context.TODO(),
+				config.WithCredentialsProvider(
+					credentials.NewStaticCredentialsProvider(
+						strings.TrimSpace(c.AccessKeyID),
+						strings.TrimSpace(c.SecretAccessKey),
+						strings.TrimSpace(c.SessionToken),
+					),
+				),
+			)
+			if err != nil {
+				return nil, err
+			}
+			c.config = &cfg
+			return c.config, nil
+		}
+
+		profile := "default"
+		if c.HasProfile() {
+			profile = c.Profile
+		}
+
+		if region == GlobalRegionID {
+			region = "aws-global"
+		}
+
+		cfg, err := config.LoadDefaultConfig(context.TODO(),
+			config.WithRegion(region),
+			config.WithSharedConfigProfile(profile),
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		// if given a role to assume, overwrite the cfg credentials with assume role credentials
+		if c.AssumeRoleArn != "" {
+			stsSvc := sts.NewFromConfig(cfg)
+			creds := stscreds.NewAssumeRoleProvider(stsSvc, c.AssumeRoleArn)
+			cfg.Credentials = aws.NewCredentialsCache(creds)
+		}
+
+		c.config = &cfg
+	} else if c.config.Region != region {
+		c.config.Region = region
+	}
+
+	return c.config, nil
+}
diff --git a/pkg/awsutil/session.go b/pkg/awsutil/session.go
index b2bfd2dc8..5635069e1 100644
--- a/pkg/awsutil/session.go
+++ b/pkg/awsutil/session.go
@@ -7,6 +7,8 @@ import (
 	"net/http"
 	"strings"
 
+	v2aws "github.com/aws/aws-sdk-go-v2/aws"
+
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/credentials"
 	"github.com/aws/aws-sdk-go/aws/credentials/stscreds"
@@ -42,6 +44,8 @@ type Credentials struct {
 
 	CustomEndpoints config.CustomEndpoints
 	session         *session.Session
+
+	config *v2aws.Config
 }
 
 func (c *Credentials) HasProfile() bool {
diff --git a/resources/cloudcontrol.go b/resources/cloudcontrol.go
index 735d18a4b..3f1a11a5d 100644
--- a/resources/cloudcontrol.go
+++ b/resources/cloudcontrol.go
@@ -36,7 +36,6 @@ func init() {
 	registerCloudControl("AWS::Timestream::ScheduledQuery")
 	registerCloudControl("AWS::Timestream::Table")
 	registerCloudControl("AWS::Transfer::Workflow")
-	registerCloudControl("AWS::NetworkFirewall::Firewall")
 	registerCloudControl("AWS::NetworkFirewall::FirewallPolicy")
 	registerCloudControl("AWS::NetworkFirewall::RuleGroup")
 }
diff --git a/resources/interface.go b/resources/interface.go
index 42922a0f2..af8035ea0 100644
--- a/resources/interface.go
+++ b/resources/interface.go
@@ -4,15 +4,19 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/rebuy-de/aws-nuke/v2/pkg/config"
 	"github.com/rebuy-de/aws-nuke/v2/pkg/types"
 )
 
 type ResourceListers map[string]ResourceLister
+type ResourceListersV2 map[string]ResourceListerV2
 
 type ResourceLister func(s *session.Session) ([]Resource, error)
 
+type ResourceListerV2 func(s *aws.Config) ([]Resource, error)
+
 type Resource interface {
 	Remove() error
 }
@@ -38,6 +42,7 @@ type FeatureFlagGetter interface {
 }
 
 var resourceListers = make(ResourceListers)
+var resourceListersV2 = make(ResourceListersV2)
 
 func register(name string, lister ResourceLister, opts ...registerOption) {
 	_, exists := resourceListers[name]
@@ -52,6 +57,19 @@ func register(name string, lister ResourceLister, opts ...registerOption) {
 	}
 }
 
+func registerV2(name string, lister ResourceListerV2, opts ...registerOptionV2) {
+	_, exists := resourceListersV2[name]
+	if exists {
+		panic(fmt.Sprintf("a resource with the name %s already exists", name))
+	}
+
+	resourceListersV2[name] = lister
+
+	for _, opt := range opts {
+		opt(name, lister)
+	}
+}
+
 var cloudControlMapping = map[string]string{}
 
 func GetCloudControlMapping() map[string]string {
@@ -59,6 +77,7 @@ func GetCloudControlMapping() map[string]string {
 }
 
 type registerOption func(name string, lister ResourceLister)
+type registerOptionV2 func(name string, lister ResourceListerV2)
 
 func mapCloudControl(typeName string) registerOption {
 	return func(name string, lister ResourceLister) {
@@ -78,11 +97,18 @@ func GetLister(name string) ResourceLister {
 	return resourceListers[name]
 }
 
+func GetListerV2(name string) ResourceListerV2 {
+	return resourceListersV2[name]
+}
+
 func GetListerNames() []string {
 	names := []string{}
 	for resourceType := range resourceListers {
 		names = append(names, resourceType)
 	}
+	for resourceType := range resourceListersV2 {
+		names = append(names, resourceType)
+	}
 
 	return names
 }
diff --git a/resources/network-firewall.go b/resources/network-firewall.go
new file mode 100644
index 000000000..b8463468c
--- /dev/null
+++ b/resources/network-firewall.go
@@ -0,0 +1,131 @@
+package resources
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/networkfirewall"
+	networkfirwallTypes "github.com/aws/aws-sdk-go-v2/service/networkfirewall/types"
+
+	"github.com/rebuy-de/aws-nuke/v2/pkg/types"
+)
+
+type NetworkFirewall struct {
+	svc *networkfirewall.Client
+
+	firewall  networkfirwallTypes.FirewallMetadata
+	logConfig *networkfirwallTypes.LoggingConfiguration
+	tags      []networkfirwallTypes.Tag
+}
+
+func init() {
+	registerV2("NetworkFirewall", ListNetworkFirewalls)
+}
+
+func ListNetworkFirewalls(cfg *aws.Config) ([]Resource, error) {
+	ctx := context.TODO()
+	svc := networkfirewall.NewFromConfig(*cfg)
+
+	resources := []Resource{}
+
+	params := &networkfirewall.ListFirewallsInput{
+		MaxResults: aws.Int32(100),
+	}
+
+	for {
+		resp, err := svc.ListFirewalls(ctx, params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, firewall := range resp.Firewalls {
+			tagParams := &networkfirewall.ListTagsForResourceInput{
+				ResourceArn: firewall.FirewallArn,
+				MaxResults:  aws.Int32(100),
+			}
+
+			tags := []networkfirwallTypes.Tag{}
+			for {
+				tagResp, tagErr := svc.ListTagsForResource(ctx, tagParams)
+				if tagErr != nil {
+					return nil, tagErr
+				}
+
+				tags = append(tags, tagResp.Tags...)
+
+				if tagResp.NextToken == nil {
+					break
+				}
+				tagParams.NextToken = tagResp.NextToken
+			}
+
+			// logging configuration required to delete firewall
+			logResp, err := svc.DescribeLoggingConfiguration(ctx, &networkfirewall.DescribeLoggingConfigurationInput{
+				FirewallArn: firewall.FirewallArn,
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			resources = append(resources, &NetworkFirewall{
+				svc:       svc,
+				firewall:  firewall,
+				logConfig: logResp.LoggingConfiguration,
+				tags:      tags,
+			})
+		}
+		if resp.NextToken == nil {
+			break
+		}
+
+		params.NextToken = resp.NextToken
+	}
+	return resources, nil
+}
+
+func (i *NetworkFirewall) Remove() error {
+	ctx := context.TODO()
+
+	if i.logConfig != nil {
+		for index := 1; index <= len(i.logConfig.LogDestinationConfigs); index++ {
+			// aws forces to only remove one at a time
+			_, err := i.svc.UpdateLoggingConfiguration(ctx, &networkfirewall.UpdateLoggingConfigurationInput{
+				FirewallArn: i.firewall.FirewallArn,
+				LoggingConfiguration: &networkfirwallTypes.LoggingConfiguration{
+					LogDestinationConfigs: i.logConfig.LogDestinationConfigs[index:],
+				},
+			})
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	params := &networkfirewall.DeleteFirewallInput{
+		FirewallArn: i.firewall.FirewallArn,
+	}
+
+	_, err := i.svc.DeleteFirewall(ctx, params)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (i *NetworkFirewall) Properties() types.Properties {
+	properties := types.NewProperties()
+	properties.Set("ARN", *i.firewall.FirewallArn)
+	properties.Set("Name", *i.firewall.FirewallName)
+	properties.Set("Logging Configured", i.logConfig != nil)
+
+	for _, tag := range i.tags {
+		properties.SetTag(tag.Key, *tag.Value)
+	}
+
+	return properties
+}
+
+func (i *NetworkFirewall) String() string {
+	return *i.firewall.FirewallArn
+}