diff --git a/aws-sdk.version b/aws-sdk.version
index 71eb27cd..f50b71f0 100755
--- a/aws-sdk.version
+++ b/aws-sdk.version
@@ -1 +1 @@
-v1.46.0
+v1.46.1
diff --git a/go.mod b/go.mod
index bd93411b..e049ae2e 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,7 @@ module github.com/Itarix/aws-sdk-go-mocks
 go 1.15
 
 require (
-	github.com/aws/aws-sdk-go v1.46.0
+	github.com/aws/aws-sdk-go v1.46.1
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/golang/mock v1.4.4
 	github.com/pmezard/go-difflib v1.0.0 // indirect
diff --git a/go.sum b/go.sum
index a4ca88ac..b968890d 100644
--- a/go.sum
+++ b/go.sum
@@ -2282,6 +2282,8 @@ github.com/aws/aws-sdk-go v1.45.28 h1:p2ATcaK6ffSw4yZ2UAGzgRyRXwKyOJY6ZCiKqj5miJ
 github.com/aws/aws-sdk-go v1.45.28/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
 github.com/aws/aws-sdk-go v1.46.0 h1:Igh7W8P+sA6mXJ9yhreOSweefLapcqekhxQlY1llxcM=
 github.com/aws/aws-sdk-go v1.46.0/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
+github.com/aws/aws-sdk-go v1.46.1 h1:U26quvBWFZMQuultLw5tloW4GnmWaChEwMZNq8uYatw=
+github.com/aws/aws-sdk-go v1.46.1/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
diff --git a/service/applicationdiscoveryservicemock/mock.go b/service/applicationdiscoveryservicemock/mock.go
index ef861387..c4526e4f 100644
--- a/service/applicationdiscoveryservicemock/mock.go
+++ b/service/applicationdiscoveryservicemock/mock.go
@@ -85,6 +85,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) AssociateConfiguration
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateConfigurationItemsToApplicationWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).AssociateConfigurationItemsToApplicationWithContext), varargs...)
 }
 
+// BatchDeleteAgents mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgents(arg0 *applicationdiscoveryservice.BatchDeleteAgentsInput) (*applicationdiscoveryservice.BatchDeleteAgentsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchDeleteAgents", arg0)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.BatchDeleteAgentsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchDeleteAgents indicates an expected call of BatchDeleteAgents
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgents(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteAgents", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgents), arg0)
+}
+
+// BatchDeleteAgentsRequest mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgentsRequest(arg0 *applicationdiscoveryservice.BatchDeleteAgentsInput) (*request.Request, *applicationdiscoveryservice.BatchDeleteAgentsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchDeleteAgentsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*applicationdiscoveryservice.BatchDeleteAgentsOutput)
+	return ret0, ret1
+}
+
+// BatchDeleteAgentsRequest indicates an expected call of BatchDeleteAgentsRequest
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgentsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteAgentsRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgentsRequest), arg0)
+}
+
+// BatchDeleteAgentsWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteAgentsWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.BatchDeleteAgentsInput, arg2 ...request.Option) (*applicationdiscoveryservice.BatchDeleteAgentsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BatchDeleteAgentsWithContext", varargs...)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.BatchDeleteAgentsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchDeleteAgentsWithContext indicates an expected call of BatchDeleteAgentsWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) BatchDeleteAgentsWithContext(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, "BatchDeleteAgentsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).BatchDeleteAgentsWithContext), varargs...)
+}
+
 // BatchDeleteImportData mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) BatchDeleteImportData(arg0 *applicationdiscoveryservice.BatchDeleteImportDataInput) (*applicationdiscoveryservice.BatchDeleteImportDataOutput, error) {
 	m.ctrl.T.Helper()
@@ -350,6 +400,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgents(arg0 in
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgents", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgents), arg0)
 }
 
+// DescribeAgentsPages mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsPages(arg0 *applicationdiscoveryservice.DescribeAgentsInput, arg1 func(*applicationdiscoveryservice.DescribeAgentsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeAgentsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeAgentsPages indicates an expected call of DescribeAgentsPages
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgentsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsPages), arg0, arg1)
+}
+
+// DescribeAgentsPagesWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeAgentsInput, arg2 func(*applicationdiscoveryservice.DescribeAgentsOutput, 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, "DescribeAgentsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeAgentsPagesWithContext indicates an expected call of DescribeAgentsPagesWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsPagesWithContext(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, "DescribeAgentsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsPagesWithContext), varargs...)
+}
+
 // DescribeAgentsRequest mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) DescribeAgentsRequest(arg0 *applicationdiscoveryservice.DescribeAgentsInput) (*request.Request, *applicationdiscoveryservice.DescribeAgentsOutput) {
 	m.ctrl.T.Helper()
@@ -385,6 +468,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeAgentsWithCont
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAgentsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeAgentsWithContext), varargs...)
 }
 
+// DescribeBatchDeleteConfigurationTask mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTask(arg0 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput) (*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTask", arg0)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeBatchDeleteConfigurationTask indicates an expected call of DescribeBatchDeleteConfigurationTask
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTask(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBatchDeleteConfigurationTask", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTask), arg0)
+}
+
+// DescribeBatchDeleteConfigurationTaskRequest mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTaskRequest(arg0 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput) (*request.Request, *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTaskRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput)
+	return ret0, ret1
+}
+
+// DescribeBatchDeleteConfigurationTaskRequest indicates an expected call of DescribeBatchDeleteConfigurationTaskRequest
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTaskRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBatchDeleteConfigurationTaskRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTaskRequest), arg0)
+}
+
+// DescribeBatchDeleteConfigurationTaskWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeBatchDeleteConfigurationTaskWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskInput, arg2 ...request.Option) (*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeBatchDeleteConfigurationTaskWithContext", varargs...)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.DescribeBatchDeleteConfigurationTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeBatchDeleteConfigurationTaskWithContext indicates an expected call of DescribeBatchDeleteConfigurationTaskWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeBatchDeleteConfigurationTaskWithContext(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, "DescribeBatchDeleteConfigurationTaskWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeBatchDeleteConfigurationTaskWithContext), varargs...)
+}
+
 // DescribeConfigurations mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) DescribeConfigurations(arg0 *applicationdiscoveryservice.DescribeConfigurationsInput) (*applicationdiscoveryservice.DescribeConfigurationsOutput, error) {
 	m.ctrl.T.Helper()
@@ -533,6 +666,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigur
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportConfigurations", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurations), arg0)
 }
 
+// DescribeExportConfigurationsPages mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsPages(arg0 *applicationdiscoveryservice.DescribeExportConfigurationsInput, arg1 func(*applicationdiscoveryservice.DescribeExportConfigurationsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeExportConfigurationsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeExportConfigurationsPages indicates an expected call of DescribeExportConfigurationsPages
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportConfigurationsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurationsPages), arg0, arg1)
+}
+
+// DescribeExportConfigurationsPagesWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeExportConfigurationsInput, arg2 func(*applicationdiscoveryservice.DescribeExportConfigurationsOutput, 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, "DescribeExportConfigurationsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeExportConfigurationsPagesWithContext indicates an expected call of DescribeExportConfigurationsPagesWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportConfigurationsPagesWithContext(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, "DescribeExportConfigurationsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportConfigurationsPagesWithContext), varargs...)
+}
+
 // DescribeExportConfigurationsRequest mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) DescribeExportConfigurationsRequest(arg0 *applicationdiscoveryservice.DescribeExportConfigurationsInput) (*request.Request, *applicationdiscoveryservice.DescribeExportConfigurationsOutput) {
 	m.ctrl.T.Helper()
@@ -583,6 +749,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasks(ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasks), arg0)
 }
 
+// DescribeExportTasksPages mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksPages(arg0 *applicationdiscoveryservice.DescribeExportTasksInput, arg1 func(*applicationdiscoveryservice.DescribeExportTasksOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeExportTasksPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeExportTasksPages indicates an expected call of DescribeExportTasksPages
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasksPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasksPages), arg0, arg1)
+}
+
+// DescribeExportTasksPagesWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeExportTasksInput, arg2 func(*applicationdiscoveryservice.DescribeExportTasksOutput, 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, "DescribeExportTasksPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeExportTasksPagesWithContext indicates an expected call of DescribeExportTasksPagesWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeExportTasksPagesWithContext(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, "DescribeExportTasksPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeExportTasksPagesWithContext), varargs...)
+}
+
 // DescribeExportTasksRequest mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) DescribeExportTasksRequest(arg0 *applicationdiscoveryservice.DescribeExportTasksInput) (*request.Request, *applicationdiscoveryservice.DescribeExportTasksOutput) {
 	m.ctrl.T.Helper()
@@ -716,6 +915,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTags(arg0 inte
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTags), arg0)
 }
 
+// DescribeTagsPages mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsPages(arg0 *applicationdiscoveryservice.DescribeTagsInput, arg1 func(*applicationdiscoveryservice.DescribeTagsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeTagsPages indicates an expected call of DescribeTagsPages
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTagsPages), arg0, arg1)
+}
+
+// DescribeTagsPagesWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.DescribeTagsInput, arg2 func(*applicationdiscoveryservice.DescribeTagsOutput, 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, "DescribeTagsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) DescribeTagsPagesWithContext(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, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).DescribeTagsPagesWithContext), varargs...)
+}
+
 // DescribeTagsRequest mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) DescribeTagsRequest(arg0 *applicationdiscoveryservice.DescribeTagsInput) (*request.Request, *applicationdiscoveryservice.DescribeTagsOutput) {
 	m.ctrl.T.Helper()
@@ -916,6 +1148,39 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurations(arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurations", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurations), arg0)
 }
 
+// ListConfigurationsPages mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsPages(arg0 *applicationdiscoveryservice.ListConfigurationsInput, arg1 func(*applicationdiscoveryservice.ListConfigurationsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListConfigurationsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListConfigurationsPages indicates an expected call of ListConfigurationsPages
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurationsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConfigurationsPages", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurationsPages), arg0, arg1)
+}
+
+// ListConfigurationsPagesWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsPagesWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.ListConfigurationsInput, arg2 func(*applicationdiscoveryservice.ListConfigurationsOutput, 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, "ListConfigurationsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListConfigurationsPagesWithContext indicates an expected call of ListConfigurationsPagesWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListConfigurationsPagesWithContext(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, "ListConfigurationsPagesWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListConfigurationsPagesWithContext), varargs...)
+}
+
 // ListConfigurationsRequest mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) ListConfigurationsRequest(arg0 *applicationdiscoveryservice.ListConfigurationsInput) (*request.Request, *applicationdiscoveryservice.ListConfigurationsOutput) {
 	m.ctrl.T.Helper()
@@ -1001,6 +1266,56 @@ func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) ListServerNeighborsWit
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerNeighborsWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).ListServerNeighborsWithContext), varargs...)
 }
 
+// StartBatchDeleteConfigurationTask mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTask(arg0 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput) (*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTask", arg0)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartBatchDeleteConfigurationTask indicates an expected call of StartBatchDeleteConfigurationTask
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTask(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartBatchDeleteConfigurationTask", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTask), arg0)
+}
+
+// StartBatchDeleteConfigurationTaskRequest mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTaskRequest(arg0 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput) (*request.Request, *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTaskRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput)
+	return ret0, ret1
+}
+
+// StartBatchDeleteConfigurationTaskRequest indicates an expected call of StartBatchDeleteConfigurationTaskRequest
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTaskRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartBatchDeleteConfigurationTaskRequest", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTaskRequest), arg0)
+}
+
+// StartBatchDeleteConfigurationTaskWithContext mocks base method
+func (m *MockApplicationDiscoveryServiceAPI) StartBatchDeleteConfigurationTaskWithContext(arg0 context.Context, arg1 *applicationdiscoveryservice.StartBatchDeleteConfigurationTaskInput, arg2 ...request.Option) (*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StartBatchDeleteConfigurationTaskWithContext", varargs...)
+	ret0, _ := ret[0].(*applicationdiscoveryservice.StartBatchDeleteConfigurationTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartBatchDeleteConfigurationTaskWithContext indicates an expected call of StartBatchDeleteConfigurationTaskWithContext
+func (mr *MockApplicationDiscoveryServiceAPIMockRecorder) StartBatchDeleteConfigurationTaskWithContext(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, "StartBatchDeleteConfigurationTaskWithContext", reflect.TypeOf((*MockApplicationDiscoveryServiceAPI)(nil).StartBatchDeleteConfigurationTaskWithContext), varargs...)
+}
+
 // StartContinuousExport mocks base method
 func (m *MockApplicationDiscoveryServiceAPI) StartContinuousExport(arg0 *applicationdiscoveryservice.StartContinuousExportInput) (*applicationdiscoveryservice.StartContinuousExportOutput, error) {
 	m.ctrl.T.Helper()
diff --git a/service/connectmock/mock.go b/service/connectmock/mock.go
index 0008bdc1..a76b55b5 100644
--- a/service/connectmock/mock.go
+++ b/service/connectmock/mock.go
@@ -10916,6 +10916,56 @@ func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumber(arg0 interface{}) *gomoc
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumber", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumber), arg0)
 }
 
+// UpdatePhoneNumberMetadata mocks base method
+func (m *MockConnectAPI) UpdatePhoneNumberMetadata(arg0 *connect.UpdatePhoneNumberMetadataInput) (*connect.UpdatePhoneNumberMetadataOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadata", arg0)
+	ret0, _ := ret[0].(*connect.UpdatePhoneNumberMetadataOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePhoneNumberMetadata indicates an expected call of UpdatePhoneNumberMetadata
+func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadata(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberMetadata", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadata), arg0)
+}
+
+// UpdatePhoneNumberMetadataRequest mocks base method
+func (m *MockConnectAPI) UpdatePhoneNumberMetadataRequest(arg0 *connect.UpdatePhoneNumberMetadataInput) (*request.Request, *connect.UpdatePhoneNumberMetadataOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadataRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*connect.UpdatePhoneNumberMetadataOutput)
+	return ret0, ret1
+}
+
+// UpdatePhoneNumberMetadataRequest indicates an expected call of UpdatePhoneNumberMetadataRequest
+func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadataRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePhoneNumberMetadataRequest", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadataRequest), arg0)
+}
+
+// UpdatePhoneNumberMetadataWithContext mocks base method
+func (m *MockConnectAPI) UpdatePhoneNumberMetadataWithContext(arg0 context.Context, arg1 *connect.UpdatePhoneNumberMetadataInput, arg2 ...request.Option) (*connect.UpdatePhoneNumberMetadataOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdatePhoneNumberMetadataWithContext", varargs...)
+	ret0, _ := ret[0].(*connect.UpdatePhoneNumberMetadataOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePhoneNumberMetadataWithContext indicates an expected call of UpdatePhoneNumberMetadataWithContext
+func (mr *MockConnectAPIMockRecorder) UpdatePhoneNumberMetadataWithContext(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, "UpdatePhoneNumberMetadataWithContext", reflect.TypeOf((*MockConnectAPI)(nil).UpdatePhoneNumberMetadataWithContext), varargs...)
+}
+
 // UpdatePhoneNumberRequest mocks base method
 func (m *MockConnectAPI) UpdatePhoneNumberRequest(arg0 *connect.UpdatePhoneNumberInput) (*request.Request, *connect.UpdatePhoneNumberOutput) {
 	m.ctrl.T.Helper()
diff --git a/service/ssmmock/mock.go b/service/ssmmock/mock.go
index 620c4907..aaa0c6a7 100644
--- a/service/ssmmock/mock.go
+++ b/service/ssmmock/mock.go
@@ -935,6 +935,56 @@ func (mr *MockSSMAPIMockRecorder) DeleteMaintenanceWindowWithContext(arg0, arg1
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaintenanceWindowWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteMaintenanceWindowWithContext), varargs...)
 }
 
+// DeleteOpsItem mocks base method
+func (m *MockSSMAPI) DeleteOpsItem(arg0 *ssm.DeleteOpsItemInput) (*ssm.DeleteOpsItemOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteOpsItem", arg0)
+	ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteOpsItem indicates an expected call of DeleteOpsItem
+func (mr *MockSSMAPIMockRecorder) DeleteOpsItem(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItem", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItem), arg0)
+}
+
+// DeleteOpsItemRequest mocks base method
+func (m *MockSSMAPI) DeleteOpsItemRequest(arg0 *ssm.DeleteOpsItemInput) (*request.Request, *ssm.DeleteOpsItemOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteOpsItemRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ssm.DeleteOpsItemOutput)
+	return ret0, ret1
+}
+
+// DeleteOpsItemRequest indicates an expected call of DeleteOpsItemRequest
+func (mr *MockSSMAPIMockRecorder) DeleteOpsItemRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpsItemRequest", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemRequest), arg0)
+}
+
+// DeleteOpsItemWithContext mocks base method
+func (m *MockSSMAPI) DeleteOpsItemWithContext(arg0 context.Context, arg1 *ssm.DeleteOpsItemInput, arg2 ...request.Option) (*ssm.DeleteOpsItemOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteOpsItemWithContext", varargs...)
+	ret0, _ := ret[0].(*ssm.DeleteOpsItemOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteOpsItemWithContext indicates an expected call of DeleteOpsItemWithContext
+func (mr *MockSSMAPIMockRecorder) DeleteOpsItemWithContext(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, "DeleteOpsItemWithContext", reflect.TypeOf((*MockSSMAPI)(nil).DeleteOpsItemWithContext), varargs...)
+}
+
 // DeleteOpsMetadata mocks base method
 func (m *MockSSMAPI) DeleteOpsMetadata(arg0 *ssm.DeleteOpsMetadataInput) (*ssm.DeleteOpsMetadataOutput, error) {
 	m.ctrl.T.Helper()