diff --git a/aws/mock/ec2.go b/aws/mock/ec2.go
index 7dc84116..50b64f8a 100644
--- a/aws/mock/ec2.go
+++ b/aws/mock/ec2.go
@@ -3586,6 +3586,56 @@ func (mr *MockEC2APIMockRecorder) CreatePlacementGroupWithContext(arg0, arg1 int
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...)
 }
 
+// CreateReplaceRootVolumeTask mocks base method.
+func (m *MockEC2API) CreateReplaceRootVolumeTask(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTask", arg0)
+	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateReplaceRootVolumeTask indicates an expected call of CreateReplaceRootVolumeTask.
+func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTask(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTask", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTask), arg0)
+}
+
+// CreateReplaceRootVolumeTaskRequest mocks base method.
+func (m *MockEC2API) CreateReplaceRootVolumeTaskRequest(arg0 *ec2.CreateReplaceRootVolumeTaskInput) (*request.Request, *ec2.CreateReplaceRootVolumeTaskOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.CreateReplaceRootVolumeTaskOutput)
+	return ret0, ret1
+}
+
+// CreateReplaceRootVolumeTaskRequest indicates an expected call of CreateReplaceRootVolumeTaskRequest.
+func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskRequest), arg0)
+}
+
+// CreateReplaceRootVolumeTaskWithContext mocks base method.
+func (m *MockEC2API) CreateReplaceRootVolumeTaskWithContext(arg0 context.Context, arg1 *ec2.CreateReplaceRootVolumeTaskInput, arg2 ...request.Option) (*ec2.CreateReplaceRootVolumeTaskOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateReplaceRootVolumeTaskWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.CreateReplaceRootVolumeTaskOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateReplaceRootVolumeTaskWithContext indicates an expected call of CreateReplaceRootVolumeTaskWithContext.
+func (mr *MockEC2APIMockRecorder) CreateReplaceRootVolumeTaskWithContext(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, "CreateReplaceRootVolumeTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReplaceRootVolumeTaskWithContext), varargs...)
+}
+
 // CreateReservedInstancesListing mocks base method.
 func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) {
 	m.ctrl.T.Helper()
@@ -13336,6 +13386,89 @@ func (mr *MockEC2APIMockRecorder) DescribeRegionsWithContext(arg0, arg1 interfac
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...)
 }
 
+// DescribeReplaceRootVolumeTasks mocks base method.
+func (m *MockEC2API) DescribeReplaceRootVolumeTasks(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasks", arg0)
+	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeReplaceRootVolumeTasks indicates an expected call of DescribeReplaceRootVolumeTasks.
+func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasks(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasks), arg0)
+}
+
+// DescribeReplaceRootVolumeTasksPages mocks base method.
+func (m *MockEC2API) DescribeReplaceRootVolumeTasksPages(arg0 *ec2.DescribeReplaceRootVolumeTasksInput, arg1 func(*ec2.DescribeReplaceRootVolumeTasksOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeReplaceRootVolumeTasksPages indicates an expected call of DescribeReplaceRootVolumeTasksPages.
+func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPages), arg0, arg1)
+}
+
+// DescribeReplaceRootVolumeTasksPagesWithContext mocks base method.
+func (m *MockEC2API) DescribeReplaceRootVolumeTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 func(*ec2.DescribeReplaceRootVolumeTasksOutput, 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, "DescribeReplaceRootVolumeTasksPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeReplaceRootVolumeTasksPagesWithContext indicates an expected call of DescribeReplaceRootVolumeTasksPagesWithContext.
+func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksPagesWithContext(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, "DescribeReplaceRootVolumeTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksPagesWithContext), varargs...)
+}
+
+// DescribeReplaceRootVolumeTasksRequest mocks base method.
+func (m *MockEC2API) DescribeReplaceRootVolumeTasksRequest(arg0 *ec2.DescribeReplaceRootVolumeTasksInput) (*request.Request, *ec2.DescribeReplaceRootVolumeTasksOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.DescribeReplaceRootVolumeTasksOutput)
+	return ret0, ret1
+}
+
+// DescribeReplaceRootVolumeTasksRequest indicates an expected call of DescribeReplaceRootVolumeTasksRequest.
+func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksRequest), arg0)
+}
+
+// DescribeReplaceRootVolumeTasksWithContext mocks base method.
+func (m *MockEC2API) DescribeReplaceRootVolumeTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeReplaceRootVolumeTasksInput, arg2 ...request.Option) (*ec2.DescribeReplaceRootVolumeTasksOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeReplaceRootVolumeTasksWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.DescribeReplaceRootVolumeTasksOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeReplaceRootVolumeTasksWithContext indicates an expected call of DescribeReplaceRootVolumeTasksWithContext.
+func (mr *MockEC2APIMockRecorder) DescribeReplaceRootVolumeTasksWithContext(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, "DescribeReplaceRootVolumeTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReplaceRootVolumeTasksWithContext), varargs...)
+}
+
 // DescribeReservedInstances mocks base method.
 func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) {
 	m.ctrl.T.Helper()
@@ -17241,6 +17374,56 @@ func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresWithContext(arg0, a
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresWithContext), varargs...)
 }
 
+// DisableSerialConsoleAccess mocks base method.
+func (m *MockEC2API) DisableSerialConsoleAccess(arg0 *ec2.DisableSerialConsoleAccessInput) (*ec2.DisableSerialConsoleAccessOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DisableSerialConsoleAccess", arg0)
+	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DisableSerialConsoleAccess indicates an expected call of DisableSerialConsoleAccess.
+func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccess), arg0)
+}
+
+// DisableSerialConsoleAccessRequest mocks base method.
+func (m *MockEC2API) DisableSerialConsoleAccessRequest(arg0 *ec2.DisableSerialConsoleAccessInput) (*request.Request, *ec2.DisableSerialConsoleAccessOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.DisableSerialConsoleAccessOutput)
+	return ret0, ret1
+}
+
+// DisableSerialConsoleAccessRequest indicates an expected call of DisableSerialConsoleAccessRequest.
+func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessRequest), arg0)
+}
+
+// DisableSerialConsoleAccessWithContext mocks base method.
+func (m *MockEC2API) DisableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.DisableSerialConsoleAccessOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DisableSerialConsoleAccessWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.DisableSerialConsoleAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DisableSerialConsoleAccessWithContext indicates an expected call of DisableSerialConsoleAccessWithContext.
+func (mr *MockEC2APIMockRecorder) DisableSerialConsoleAccessWithContext(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, "DisableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableSerialConsoleAccessWithContext), varargs...)
+}
+
 // DisableTransitGatewayRouteTablePropagation mocks base method.
 func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) {
 	m.ctrl.T.Helper()
@@ -17991,6 +18174,56 @@ func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(arg0, ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...)
 }
 
+// EnableSerialConsoleAccess mocks base method.
+func (m *MockEC2API) EnableSerialConsoleAccess(arg0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EnableSerialConsoleAccess", arg0)
+	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EnableSerialConsoleAccess indicates an expected call of EnableSerialConsoleAccess.
+func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccess(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccess", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccess), arg0)
+}
+
+// EnableSerialConsoleAccessRequest mocks base method.
+func (m *MockEC2API) EnableSerialConsoleAccessRequest(arg0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.EnableSerialConsoleAccessOutput)
+	return ret0, ret1
+}
+
+// EnableSerialConsoleAccessRequest indicates an expected call of EnableSerialConsoleAccessRequest.
+func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessRequest), arg0)
+}
+
+// EnableSerialConsoleAccessWithContext mocks base method.
+func (m *MockEC2API) EnableSerialConsoleAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSerialConsoleAccessInput, arg2 ...request.Option) (*ec2.EnableSerialConsoleAccessOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "EnableSerialConsoleAccessWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EnableSerialConsoleAccessWithContext indicates an expected call of EnableSerialConsoleAccessWithContext.
+func (mr *MockEC2APIMockRecorder) EnableSerialConsoleAccessWithContext(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, "EnableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableSerialConsoleAccessWithContext), varargs...)
+}
+
 // EnableTransitGatewayRouteTablePropagation mocks base method.
 func (m *MockEC2API) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) {
 	m.ctrl.T.Helper()
@@ -18924,6 +19157,56 @@ func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultWithContext(arg0, arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...)
 }
 
+// GetFlowLogsIntegrationTemplate mocks base method.
+func (m *MockEC2API) GetFlowLogsIntegrationTemplate(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplate", arg0)
+	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFlowLogsIntegrationTemplate indicates an expected call of GetFlowLogsIntegrationTemplate.
+func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplate", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplate), arg0)
+}
+
+// GetFlowLogsIntegrationTemplateRequest mocks base method.
+func (m *MockEC2API) GetFlowLogsIntegrationTemplateRequest(arg0 *ec2.GetFlowLogsIntegrationTemplateInput) (*request.Request, *ec2.GetFlowLogsIntegrationTemplateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.GetFlowLogsIntegrationTemplateOutput)
+	return ret0, ret1
+}
+
+// GetFlowLogsIntegrationTemplateRequest indicates an expected call of GetFlowLogsIntegrationTemplateRequest.
+func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateRequest), arg0)
+}
+
+// GetFlowLogsIntegrationTemplateWithContext mocks base method.
+func (m *MockEC2API) GetFlowLogsIntegrationTemplateWithContext(arg0 context.Context, arg1 *ec2.GetFlowLogsIntegrationTemplateInput, arg2 ...request.Option) (*ec2.GetFlowLogsIntegrationTemplateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetFlowLogsIntegrationTemplateWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.GetFlowLogsIntegrationTemplateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFlowLogsIntegrationTemplateWithContext indicates an expected call of GetFlowLogsIntegrationTemplateWithContext.
+func (mr *MockEC2APIMockRecorder) GetFlowLogsIntegrationTemplateWithContext(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, "GetFlowLogsIntegrationTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).GetFlowLogsIntegrationTemplateWithContext), varargs...)
+}
+
 // GetGroupsForCapacityReservation mocks base method.
 func (m *MockEC2API) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) {
 	m.ctrl.T.Helper()
@@ -19373,6 +19656,56 @@ func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteWithContext(a
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...)
 }
 
+// GetSerialConsoleAccessStatus mocks base method.
+func (m *MockEC2API) GetSerialConsoleAccessStatus(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatus", arg0)
+	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSerialConsoleAccessStatus indicates an expected call of GetSerialConsoleAccessStatus.
+func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatus(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatus", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatus), arg0)
+}
+
+// GetSerialConsoleAccessStatusRequest mocks base method.
+func (m *MockEC2API) GetSerialConsoleAccessStatusRequest(arg0 *ec2.GetSerialConsoleAccessStatusInput) (*request.Request, *ec2.GetSerialConsoleAccessStatusOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ec2.GetSerialConsoleAccessStatusOutput)
+	return ret0, ret1
+}
+
+// GetSerialConsoleAccessStatusRequest indicates an expected call of GetSerialConsoleAccessStatusRequest.
+func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatusRequest", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusRequest), arg0)
+}
+
+// GetSerialConsoleAccessStatusWithContext mocks base method.
+func (m *MockEC2API) GetSerialConsoleAccessStatusWithContext(arg0 context.Context, arg1 *ec2.GetSerialConsoleAccessStatusInput, arg2 ...request.Option) (*ec2.GetSerialConsoleAccessStatusOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSerialConsoleAccessStatusWithContext", varargs...)
+	ret0, _ := ret[0].(*ec2.GetSerialConsoleAccessStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSerialConsoleAccessStatusWithContext indicates an expected call of GetSerialConsoleAccessStatusWithContext.
+func (mr *MockEC2APIMockRecorder) GetSerialConsoleAccessStatusWithContext(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, "GetSerialConsoleAccessStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).GetSerialConsoleAccessStatusWithContext), varargs...)
+}
+
 // GetTransitGatewayAttachmentPropagations mocks base method.
 func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) {
 	m.ctrl.T.Helper()
diff --git a/aws/mock/ecs.go b/aws/mock/ecs.go
index 346a2af2..aea1aba3 100644
--- a/aws/mock/ecs.go
+++ b/aws/mock/ecs.go
@@ -1036,6 +1036,56 @@ func (mr *MockECSAPIMockRecorder) DiscoverPollEndpointWithContext(arg0, arg1 int
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpointWithContext", reflect.TypeOf((*MockECSAPI)(nil).DiscoverPollEndpointWithContext), varargs...)
 }
 
+// ExecuteCommand mocks base method.
+func (m *MockECSAPI) ExecuteCommand(arg0 *ecs.ExecuteCommandInput) (*ecs.ExecuteCommandOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteCommand", arg0)
+	ret0, _ := ret[0].(*ecs.ExecuteCommandOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteCommand indicates an expected call of ExecuteCommand.
+func (mr *MockECSAPIMockRecorder) ExecuteCommand(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteCommand", reflect.TypeOf((*MockECSAPI)(nil).ExecuteCommand), arg0)
+}
+
+// ExecuteCommandRequest mocks base method.
+func (m *MockECSAPI) ExecuteCommandRequest(arg0 *ecs.ExecuteCommandInput) (*request.Request, *ecs.ExecuteCommandOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteCommandRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ecs.ExecuteCommandOutput)
+	return ret0, ret1
+}
+
+// ExecuteCommandRequest indicates an expected call of ExecuteCommandRequest.
+func (mr *MockECSAPIMockRecorder) ExecuteCommandRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteCommandRequest", reflect.TypeOf((*MockECSAPI)(nil).ExecuteCommandRequest), arg0)
+}
+
+// ExecuteCommandWithContext mocks base method.
+func (m *MockECSAPI) ExecuteCommandWithContext(arg0 context.Context, arg1 *ecs.ExecuteCommandInput, arg2 ...request.Option) (*ecs.ExecuteCommandOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ExecuteCommandWithContext", varargs...)
+	ret0, _ := ret[0].(*ecs.ExecuteCommandOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteCommandWithContext indicates an expected call of ExecuteCommandWithContext.
+func (mr *MockECSAPIMockRecorder) ExecuteCommandWithContext(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, "ExecuteCommandWithContext", reflect.TypeOf((*MockECSAPI)(nil).ExecuteCommandWithContext), varargs...)
+}
+
 // ListAccountSettings mocks base method.
 func (m *MockECSAPI) ListAccountSettings(arg0 *ecs.ListAccountSettingsInput) (*ecs.ListAccountSettingsOutput, error) {
 	m.ctrl.T.Helper()
@@ -2500,6 +2550,36 @@ func (mr *MockECSAPIMockRecorder) UpdateCapacityProviderWithContext(arg0, arg1 i
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCapacityProviderWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateCapacityProviderWithContext), varargs...)
 }
 
+// UpdateCluster mocks base method.
+func (m *MockECSAPI) UpdateCluster(arg0 *ecs.UpdateClusterInput) (*ecs.UpdateClusterOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateCluster", arg0)
+	ret0, _ := ret[0].(*ecs.UpdateClusterOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateCluster indicates an expected call of UpdateCluster.
+func (mr *MockECSAPIMockRecorder) UpdateCluster(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockECSAPI)(nil).UpdateCluster), arg0)
+}
+
+// UpdateClusterRequest mocks base method.
+func (m *MockECSAPI) UpdateClusterRequest(arg0 *ecs.UpdateClusterInput) (*request.Request, *ecs.UpdateClusterOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateClusterRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*ecs.UpdateClusterOutput)
+	return ret0, ret1
+}
+
+// UpdateClusterRequest indicates an expected call of UpdateClusterRequest.
+func (mr *MockECSAPIMockRecorder) UpdateClusterRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRequest", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterRequest), arg0)
+}
+
 // UpdateClusterSettings mocks base method.
 func (m *MockECSAPI) UpdateClusterSettings(arg0 *ecs.UpdateClusterSettingsInput) (*ecs.UpdateClusterSettingsOutput, error) {
 	m.ctrl.T.Helper()
@@ -2550,6 +2630,26 @@ func (mr *MockECSAPIMockRecorder) UpdateClusterSettingsWithContext(arg0, arg1 in
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSettingsWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterSettingsWithContext), varargs...)
 }
 
+// UpdateClusterWithContext mocks base method.
+func (m *MockECSAPI) UpdateClusterWithContext(arg0 context.Context, arg1 *ecs.UpdateClusterInput, arg2 ...request.Option) (*ecs.UpdateClusterOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateClusterWithContext", varargs...)
+	ret0, _ := ret[0].(*ecs.UpdateClusterOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateClusterWithContext indicates an expected call of UpdateClusterWithContext.
+func (mr *MockECSAPIMockRecorder) UpdateClusterWithContext(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, "UpdateClusterWithContext", reflect.TypeOf((*MockECSAPI)(nil).UpdateClusterWithContext), varargs...)
+}
+
 // UpdateContainerAgent mocks base method.
 func (m *MockECSAPI) UpdateContainerAgent(arg0 *ecs.UpdateContainerAgentInput) (*ecs.UpdateContainerAgentOutput, error) {
 	m.ctrl.T.Helper()
diff --git a/aws/mock/rds.go b/aws/mock/rds.go
index 730a9a79..8ffe7592 100644
--- a/aws/mock/rds.go
+++ b/aws/mock/rds.go
@@ -1101,6 +1101,56 @@ func (mr *MockRDSAPIMockRecorder) CreateDBProxy(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxy), arg0)
 }
 
+// CreateDBProxyEndpoint mocks base method.
+func (m *MockRDSAPI) CreateDBProxyEndpoint(arg0 *rds.CreateDBProxyEndpointInput) (*rds.CreateDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDBProxyEndpoint", arg0)
+	ret0, _ := ret[0].(*rds.CreateDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDBProxyEndpoint indicates an expected call of CreateDBProxyEndpoint.
+func (mr *MockRDSAPIMockRecorder) CreateDBProxyEndpoint(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxyEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxyEndpoint), arg0)
+}
+
+// CreateDBProxyEndpointRequest mocks base method.
+func (m *MockRDSAPI) CreateDBProxyEndpointRequest(arg0 *rds.CreateDBProxyEndpointInput) (*request.Request, *rds.CreateDBProxyEndpointOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDBProxyEndpointRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*rds.CreateDBProxyEndpointOutput)
+	return ret0, ret1
+}
+
+// CreateDBProxyEndpointRequest indicates an expected call of CreateDBProxyEndpointRequest.
+func (mr *MockRDSAPIMockRecorder) CreateDBProxyEndpointRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDBProxyEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxyEndpointRequest), arg0)
+}
+
+// CreateDBProxyEndpointWithContext mocks base method.
+func (m *MockRDSAPI) CreateDBProxyEndpointWithContext(arg0 context.Context, arg1 *rds.CreateDBProxyEndpointInput, arg2 ...request.Option) (*rds.CreateDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateDBProxyEndpointWithContext", varargs...)
+	ret0, _ := ret[0].(*rds.CreateDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDBProxyEndpointWithContext indicates an expected call of CreateDBProxyEndpointWithContext.
+func (mr *MockRDSAPIMockRecorder) CreateDBProxyEndpointWithContext(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, "CreateDBProxyEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).CreateDBProxyEndpointWithContext), varargs...)
+}
+
 // CreateDBProxyRequest mocks base method.
 func (m *MockRDSAPI) CreateDBProxyRequest(arg0 *rds.CreateDBProxyInput) (*request.Request, *rds.CreateDBProxyOutput) {
 	m.ctrl.T.Helper()
@@ -1851,6 +1901,56 @@ func (mr *MockRDSAPIMockRecorder) DeleteDBProxy(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxy), arg0)
 }
 
+// DeleteDBProxyEndpoint mocks base method.
+func (m *MockRDSAPI) DeleteDBProxyEndpoint(arg0 *rds.DeleteDBProxyEndpointInput) (*rds.DeleteDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDBProxyEndpoint", arg0)
+	ret0, _ := ret[0].(*rds.DeleteDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDBProxyEndpoint indicates an expected call of DeleteDBProxyEndpoint.
+func (mr *MockRDSAPIMockRecorder) DeleteDBProxyEndpoint(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxyEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxyEndpoint), arg0)
+}
+
+// DeleteDBProxyEndpointRequest mocks base method.
+func (m *MockRDSAPI) DeleteDBProxyEndpointRequest(arg0 *rds.DeleteDBProxyEndpointInput) (*request.Request, *rds.DeleteDBProxyEndpointOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDBProxyEndpointRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*rds.DeleteDBProxyEndpointOutput)
+	return ret0, ret1
+}
+
+// DeleteDBProxyEndpointRequest indicates an expected call of DeleteDBProxyEndpointRequest.
+func (mr *MockRDSAPIMockRecorder) DeleteDBProxyEndpointRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDBProxyEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxyEndpointRequest), arg0)
+}
+
+// DeleteDBProxyEndpointWithContext mocks base method.
+func (m *MockRDSAPI) DeleteDBProxyEndpointWithContext(arg0 context.Context, arg1 *rds.DeleteDBProxyEndpointInput, arg2 ...request.Option) (*rds.DeleteDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDBProxyEndpointWithContext", varargs...)
+	ret0, _ := ret[0].(*rds.DeleteDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDBProxyEndpointWithContext indicates an expected call of DeleteDBProxyEndpointWithContext.
+func (mr *MockRDSAPIMockRecorder) DeleteDBProxyEndpointWithContext(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, "DeleteDBProxyEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DeleteDBProxyEndpointWithContext), varargs...)
+}
+
 // DeleteDBProxyRequest mocks base method.
 func (m *MockRDSAPI) DeleteDBProxyRequest(arg0 *rds.DeleteDBProxyInput) (*request.Request, *rds.DeleteDBProxyOutput) {
 	m.ctrl.T.Helper()
@@ -3631,6 +3731,89 @@ func (mr *MockRDSAPIMockRecorder) DescribeDBProxiesWithContext(arg0, arg1 interf
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxiesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxiesWithContext), varargs...)
 }
 
+// DescribeDBProxyEndpoints mocks base method.
+func (m *MockRDSAPI) DescribeDBProxyEndpoints(arg0 *rds.DescribeDBProxyEndpointsInput) (*rds.DescribeDBProxyEndpointsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeDBProxyEndpoints", arg0)
+	ret0, _ := ret[0].(*rds.DescribeDBProxyEndpointsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeDBProxyEndpoints indicates an expected call of DescribeDBProxyEndpoints.
+func (mr *MockRDSAPIMockRecorder) DescribeDBProxyEndpoints(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyEndpoints", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyEndpoints), arg0)
+}
+
+// DescribeDBProxyEndpointsPages mocks base method.
+func (m *MockRDSAPI) DescribeDBProxyEndpointsPages(arg0 *rds.DescribeDBProxyEndpointsInput, arg1 func(*rds.DescribeDBProxyEndpointsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeDBProxyEndpointsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeDBProxyEndpointsPages indicates an expected call of DescribeDBProxyEndpointsPages.
+func (mr *MockRDSAPIMockRecorder) DescribeDBProxyEndpointsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyEndpointsPages", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyEndpointsPages), arg0, arg1)
+}
+
+// DescribeDBProxyEndpointsPagesWithContext mocks base method.
+func (m *MockRDSAPI) DescribeDBProxyEndpointsPagesWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyEndpointsInput, arg2 func(*rds.DescribeDBProxyEndpointsOutput, 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, "DescribeDBProxyEndpointsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DescribeDBProxyEndpointsPagesWithContext indicates an expected call of DescribeDBProxyEndpointsPagesWithContext.
+func (mr *MockRDSAPIMockRecorder) DescribeDBProxyEndpointsPagesWithContext(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, "DescribeDBProxyEndpointsPagesWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyEndpointsPagesWithContext), varargs...)
+}
+
+// DescribeDBProxyEndpointsRequest mocks base method.
+func (m *MockRDSAPI) DescribeDBProxyEndpointsRequest(arg0 *rds.DescribeDBProxyEndpointsInput) (*request.Request, *rds.DescribeDBProxyEndpointsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeDBProxyEndpointsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*rds.DescribeDBProxyEndpointsOutput)
+	return ret0, ret1
+}
+
+// DescribeDBProxyEndpointsRequest indicates an expected call of DescribeDBProxyEndpointsRequest.
+func (mr *MockRDSAPIMockRecorder) DescribeDBProxyEndpointsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDBProxyEndpointsRequest", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyEndpointsRequest), arg0)
+}
+
+// DescribeDBProxyEndpointsWithContext mocks base method.
+func (m *MockRDSAPI) DescribeDBProxyEndpointsWithContext(arg0 context.Context, arg1 *rds.DescribeDBProxyEndpointsInput, arg2 ...request.Option) (*rds.DescribeDBProxyEndpointsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeDBProxyEndpointsWithContext", varargs...)
+	ret0, _ := ret[0].(*rds.DescribeDBProxyEndpointsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeDBProxyEndpointsWithContext indicates an expected call of DescribeDBProxyEndpointsWithContext.
+func (mr *MockRDSAPIMockRecorder) DescribeDBProxyEndpointsWithContext(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, "DescribeDBProxyEndpointsWithContext", reflect.TypeOf((*MockRDSAPI)(nil).DescribeDBProxyEndpointsWithContext), varargs...)
+}
+
 // DescribeDBProxyTargetGroups mocks base method.
 func (m *MockRDSAPI) DescribeDBProxyTargetGroups(arg0 *rds.DescribeDBProxyTargetGroupsInput) (*rds.DescribeDBProxyTargetGroupsOutput, error) {
 	m.ctrl.T.Helper()
@@ -6023,6 +6206,56 @@ func (mr *MockRDSAPIMockRecorder) ModifyDBProxy(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxy", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxy), arg0)
 }
 
+// ModifyDBProxyEndpoint mocks base method.
+func (m *MockRDSAPI) ModifyDBProxyEndpoint(arg0 *rds.ModifyDBProxyEndpointInput) (*rds.ModifyDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyDBProxyEndpoint", arg0)
+	ret0, _ := ret[0].(*rds.ModifyDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyDBProxyEndpoint indicates an expected call of ModifyDBProxyEndpoint.
+func (mr *MockRDSAPIMockRecorder) ModifyDBProxyEndpoint(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyEndpoint", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyEndpoint), arg0)
+}
+
+// ModifyDBProxyEndpointRequest mocks base method.
+func (m *MockRDSAPI) ModifyDBProxyEndpointRequest(arg0 *rds.ModifyDBProxyEndpointInput) (*request.Request, *rds.ModifyDBProxyEndpointOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyDBProxyEndpointRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*rds.ModifyDBProxyEndpointOutput)
+	return ret0, ret1
+}
+
+// ModifyDBProxyEndpointRequest indicates an expected call of ModifyDBProxyEndpointRequest.
+func (mr *MockRDSAPIMockRecorder) ModifyDBProxyEndpointRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDBProxyEndpointRequest", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyEndpointRequest), arg0)
+}
+
+// ModifyDBProxyEndpointWithContext mocks base method.
+func (m *MockRDSAPI) ModifyDBProxyEndpointWithContext(arg0 context.Context, arg1 *rds.ModifyDBProxyEndpointInput, arg2 ...request.Option) (*rds.ModifyDBProxyEndpointOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ModifyDBProxyEndpointWithContext", varargs...)
+	ret0, _ := ret[0].(*rds.ModifyDBProxyEndpointOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyDBProxyEndpointWithContext indicates an expected call of ModifyDBProxyEndpointWithContext.
+func (mr *MockRDSAPIMockRecorder) ModifyDBProxyEndpointWithContext(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, "ModifyDBProxyEndpointWithContext", reflect.TypeOf((*MockRDSAPI)(nil).ModifyDBProxyEndpointWithContext), varargs...)
+}
+
 // ModifyDBProxyRequest mocks base method.
 func (m *MockRDSAPI) ModifyDBProxyRequest(arg0 *rds.ModifyDBProxyInput) (*request.Request, *rds.ModifyDBProxyOutput) {
 	m.ctrl.T.Helper()
diff --git a/go.mod b/go.mod
index 508ce053..ad8f13b3 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,7 @@ module github.com/terraform-linters/tflint-ruleset-aws
 go 1.16
 
 require (
-	github.com/aws/aws-sdk-go v1.37.25
+	github.com/aws/aws-sdk-go v1.38.12
 	github.com/dave/dst v0.26.2
 	github.com/golang/mock v1.5.0
 	github.com/google/go-cmp v0.5.5
diff --git a/go.sum b/go.sum
index 9529bdf8..2bf93ec5 100644
--- a/go.sum
+++ b/go.sum
@@ -58,8 +58,8 @@ github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3A
 github.com/aws/aws-sdk-go v1.25.3/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.31.9/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
 github.com/aws/aws-sdk-go v1.37.0/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro=
-github.com/aws/aws-sdk-go v1.37.25 h1:q1C/ILIVusSmqgWG4tFU0uVt3Zm+1I3L2BmNCd2Ug4Q=
-github.com/aws/aws-sdk-go v1.37.25/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro=
+github.com/aws/aws-sdk-go v1.38.12 h1:khtODkUna3iF53Cg3dCF4e6oWgrAEbZDU4x1aq+G0WY=
+github.com/aws/aws-sdk-go v1.38.12/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro=
 github.com/beevik/etree v1.1.0 h1:T0xke/WvNtMoCqgzPhkX2r4rjY3GDZFi+FjpRZY2Jbs=
 github.com/beevik/etree v1.1.0/go.mod h1:r8Aw8JqVegEf0w2fDnATrX9VpkMcyFeM0FhwO62wh+A=
 github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=