Generated changes

apis/apiregistration.k8s.io/v1/fakes/zz_generated_api_service_mock.go

@@ -675,6 +675,7 @@ var (
 	lockAPIServiceInterfaceMockGet                              sync.RWMutex
 	lockAPIServiceInterfaceMockGetNamespaced                    sync.RWMutex
 	lockAPIServiceInterfaceMockList                             sync.RWMutex
+	lockAPIServiceInterfaceMockListNamespaced                   sync.RWMutex
 	lockAPIServiceInterfaceMockObjectClient                     sync.RWMutex
 	lockAPIServiceInterfaceMockUpdate                           sync.RWMutex
 	lockAPIServiceInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.APIServiceInterface = &APIServiceInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.APIServiceList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.APIServiceList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type APIServiceInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.APIServiceList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.APIServiceList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type APIServiceInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *APIServiceInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *APIServiceInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.APIServiceList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("APIServiceInterfaceMock.ListNamespacedFunc: method is nil but APIServiceInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockAPIServiceInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockAPIServiceInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedAPIServiceInterface.ListNamespacedCalls())
+func (mock *APIServiceInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockAPIServiceInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockAPIServiceInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *APIServiceInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/apiregistration.k8s.io/v1/zz_generated_api_service_controller.go

@@ -85,6 +85,7 @@ type APIServiceInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*APIServiceList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*APIServiceList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() APIServiceController
@@ -272,6 +273,11 @@ func (s *apiServiceClient) List(opts metav1.ListOptions) (*APIServiceList, error
 	return obj.(*APIServiceList), err
 }
 
+func (s *apiServiceClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*APIServiceList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*APIServiceList), err
+}
+
 func (s *apiServiceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/apps/v1/fakes/zz_generated_daemon_set_mock.go

@@ -675,6 +675,7 @@ var (
 	lockDaemonSetInterfaceMockGet                              sync.RWMutex
 	lockDaemonSetInterfaceMockGetNamespaced                    sync.RWMutex
 	lockDaemonSetInterfaceMockList                             sync.RWMutex
+	lockDaemonSetInterfaceMockListNamespaced                   sync.RWMutex
 	lockDaemonSetInterfaceMockObjectClient                     sync.RWMutex
 	lockDaemonSetInterfaceMockUpdate                           sync.RWMutex
 	lockDaemonSetInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.DaemonSetInterface = &DaemonSetInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.DaemonSetList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.DaemonSetList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type DaemonSetInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.DaemonSetList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.DaemonSetList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type DaemonSetInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *DaemonSetInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *DaemonSetInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.DaemonSetList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("DaemonSetInterfaceMock.ListNamespacedFunc: method is nil but DaemonSetInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockDaemonSetInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockDaemonSetInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedDaemonSetInterface.ListNamespacedCalls())
+func (mock *DaemonSetInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockDaemonSetInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockDaemonSetInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *DaemonSetInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/apps/v1/fakes/zz_generated_deployment_mock.go

@@ -675,6 +675,7 @@ var (
 	lockDeploymentInterfaceMockGet                              sync.RWMutex
 	lockDeploymentInterfaceMockGetNamespaced                    sync.RWMutex
 	lockDeploymentInterfaceMockList                             sync.RWMutex
+	lockDeploymentInterfaceMockListNamespaced                   sync.RWMutex
 	lockDeploymentInterfaceMockObjectClient                     sync.RWMutex
 	lockDeploymentInterfaceMockUpdate                           sync.RWMutex
 	lockDeploymentInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.DeploymentInterface = &DeploymentInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.DeploymentList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.DeploymentList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type DeploymentInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.DeploymentList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.DeploymentList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type DeploymentInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *DeploymentInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *DeploymentInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.DeploymentList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("DeploymentInterfaceMock.ListNamespacedFunc: method is nil but DeploymentInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockDeploymentInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockDeploymentInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedDeploymentInterface.ListNamespacedCalls())
+func (mock *DeploymentInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockDeploymentInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockDeploymentInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *DeploymentInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/apps/v1/fakes/zz_generated_replica_set_mock.go

@@ -675,6 +675,7 @@ var (
 	lockReplicaSetInterfaceMockGet                              sync.RWMutex
 	lockReplicaSetInterfaceMockGetNamespaced                    sync.RWMutex
 	lockReplicaSetInterfaceMockList                             sync.RWMutex
+	lockReplicaSetInterfaceMockListNamespaced                   sync.RWMutex
 	lockReplicaSetInterfaceMockObjectClient                     sync.RWMutex
 	lockReplicaSetInterfaceMockUpdate                           sync.RWMutex
 	lockReplicaSetInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ReplicaSetInterface = &ReplicaSetInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ReplicaSetList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ReplicaSetList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ReplicaSetInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ReplicaSetList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ReplicaSetList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ReplicaSetInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ReplicaSetInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ReplicaSetInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ReplicaSetList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ReplicaSetInterfaceMock.ListNamespacedFunc: method is nil but ReplicaSetInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockReplicaSetInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockReplicaSetInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedReplicaSetInterface.ListNamespacedCalls())
+func (mock *ReplicaSetInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockReplicaSetInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockReplicaSetInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ReplicaSetInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/apps/v1/fakes/zz_generated_stateful_set_mock.go

@@ -675,6 +675,7 @@ var (
 	lockStatefulSetInterfaceMockGet                              sync.RWMutex
 	lockStatefulSetInterfaceMockGetNamespaced                    sync.RWMutex
 	lockStatefulSetInterfaceMockList                             sync.RWMutex
+	lockStatefulSetInterfaceMockListNamespaced                   sync.RWMutex
 	lockStatefulSetInterfaceMockObjectClient                     sync.RWMutex
 	lockStatefulSetInterfaceMockUpdate                           sync.RWMutex
 	lockStatefulSetInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.StatefulSetInterface = &StatefulSetInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.StatefulSetList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.StatefulSetList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type StatefulSetInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.StatefulSetList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.StatefulSetList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type StatefulSetInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *StatefulSetInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *StatefulSetInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.StatefulSetList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("StatefulSetInterfaceMock.ListNamespacedFunc: method is nil but StatefulSetInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockStatefulSetInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockStatefulSetInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedStatefulSetInterface.ListNamespacedCalls())
+func (mock *StatefulSetInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockStatefulSetInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockStatefulSetInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *StatefulSetInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/apps/v1/zz_generated_daemon_set_controller.go

@@ -86,6 +86,7 @@ type DaemonSetInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*DaemonSetList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*DaemonSetList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() DaemonSetController
@@ -273,6 +274,11 @@ func (s *daemonSetClient) List(opts metav1.ListOptions) (*DaemonSetList, error)
 	return obj.(*DaemonSetList), err
 }
 
+func (s *daemonSetClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*DaemonSetList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*DaemonSetList), err
+}
+
 func (s *daemonSetClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/apps/v1/zz_generated_deployment_controller.go

@@ -86,6 +86,7 @@ type DeploymentInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*DeploymentList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*DeploymentList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() DeploymentController
@@ -273,6 +274,11 @@ func (s *deploymentClient) List(opts metav1.ListOptions) (*DeploymentList, error
 	return obj.(*DeploymentList), err
 }
 
+func (s *deploymentClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*DeploymentList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*DeploymentList), err
+}
+
 func (s *deploymentClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/apps/v1/zz_generated_replica_set_controller.go

@@ -86,6 +86,7 @@ type ReplicaSetInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ReplicaSetList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ReplicaSetList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ReplicaSetController
@@ -273,6 +274,11 @@ func (s *replicaSetClient) List(opts metav1.ListOptions) (*ReplicaSetList, error
 	return obj.(*ReplicaSetList), err
 }
 
+func (s *replicaSetClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ReplicaSetList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ReplicaSetList), err
+}
+
 func (s *replicaSetClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/apps/v1/zz_generated_stateful_set_controller.go

@@ -86,6 +86,7 @@ type StatefulSetInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*StatefulSetList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*StatefulSetList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() StatefulSetController
@@ -273,6 +274,11 @@ func (s *statefulSetClient) List(opts metav1.ListOptions) (*StatefulSetList, err
 	return obj.(*StatefulSetList), err
 }
 
+func (s *statefulSetClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*StatefulSetList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*StatefulSetList), err
+}
+
 func (s *statefulSetClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/autoscaling/v2beta2/fakes/zz_generated_horizontal_pod_autoscaler_mock.go

@@ -675,6 +675,7 @@ var (
 	lockHorizontalPodAutoscalerInterfaceMockGet                              sync.RWMutex
 	lockHorizontalPodAutoscalerInterfaceMockGetNamespaced                    sync.RWMutex
 	lockHorizontalPodAutoscalerInterfaceMockList                             sync.RWMutex
+	lockHorizontalPodAutoscalerInterfaceMockListNamespaced                   sync.RWMutex
 	lockHorizontalPodAutoscalerInterfaceMockObjectClient                     sync.RWMutex
 	lockHorizontalPodAutoscalerInterfaceMockUpdate                           sync.RWMutex
 	lockHorizontalPodAutoscalerInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v2beta2a.HorizontalPodAutoscalerInterface = &HorizontalPodAutoscalerInterf
 //             ListFunc: func(opts v1.ListOptions) (*v2beta2a.HorizontalPodAutoscalerList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v2beta2a.HorizontalPodAutoscalerList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type HorizontalPodAutoscalerInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v2beta2a.HorizontalPodAutoscalerList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v2beta2a.HorizontalPodAutoscalerList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type HorizontalPodAutoscalerInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *HorizontalPodAutoscalerInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *HorizontalPodAutoscalerInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v2beta2a.HorizontalPodAutoscalerList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("HorizontalPodAutoscalerInterfaceMock.ListNamespacedFunc: method is nil but HorizontalPodAutoscalerInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockHorizontalPodAutoscalerInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockHorizontalPodAutoscalerInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedHorizontalPodAutoscalerInterface.ListNamespacedCalls())
+func (mock *HorizontalPodAutoscalerInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockHorizontalPodAutoscalerInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockHorizontalPodAutoscalerInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *HorizontalPodAutoscalerInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/autoscaling/v2beta2/zz_generated_horizontal_pod_autoscaler_controller.go

@@ -86,6 +86,7 @@ type HorizontalPodAutoscalerInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*HorizontalPodAutoscalerList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*HorizontalPodAutoscalerList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() HorizontalPodAutoscalerController
@@ -273,6 +274,11 @@ func (s *horizontalPodAutoscalerClient) List(opts metav1.ListOptions) (*Horizont
 	return obj.(*HorizontalPodAutoscalerList), err
 }
 
+func (s *horizontalPodAutoscalerClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*HorizontalPodAutoscalerList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*HorizontalPodAutoscalerList), err
+}
+
 func (s *horizontalPodAutoscalerClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/batch/v1/fakes/zz_generated_job_mock.go

@@ -675,6 +675,7 @@ var (
 	lockJobInterfaceMockGet                              sync.RWMutex
 	lockJobInterfaceMockGetNamespaced                    sync.RWMutex
 	lockJobInterfaceMockList                             sync.RWMutex
+	lockJobInterfaceMockListNamespaced                   sync.RWMutex
 	lockJobInterfaceMockObjectClient                     sync.RWMutex
 	lockJobInterfaceMockUpdate                           sync.RWMutex
 	lockJobInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.JobInterface = &JobInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.JobList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.JobList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type JobInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.JobList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.JobList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type JobInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *JobInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *JobInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.JobList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("JobInterfaceMock.ListNamespacedFunc: method is nil but JobInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockJobInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockJobInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedJobInterface.ListNamespacedCalls())
+func (mock *JobInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockJobInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockJobInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *JobInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/batch/v1/zz_generated_job_controller.go

@@ -86,6 +86,7 @@ type JobInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*JobList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*JobList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() JobController
@@ -273,6 +274,11 @@ func (s *jobClient) List(opts metav1.ListOptions) (*JobList, error) {
 	return obj.(*JobList), err
 }
 
+func (s *jobClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*JobList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*JobList), err
+}
+
 func (s *jobClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/batch/v1beta1/fakes/zz_generated_cron_job_mock.go

@@ -675,6 +675,7 @@ var (
 	lockCronJobInterfaceMockGet                              sync.RWMutex
 	lockCronJobInterfaceMockGetNamespaced                    sync.RWMutex
 	lockCronJobInterfaceMockList                             sync.RWMutex
+	lockCronJobInterfaceMockListNamespaced                   sync.RWMutex
 	lockCronJobInterfaceMockObjectClient                     sync.RWMutex
 	lockCronJobInterfaceMockUpdate                           sync.RWMutex
 	lockCronJobInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1beta1a.CronJobInterface = &CronJobInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v1beta1a.CronJobList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v1beta1a.CronJobList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type CronJobInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v1beta1a.CronJobList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v1beta1a.CronJobList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type CronJobInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *CronJobInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *CronJobInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v1beta1a.CronJobList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("CronJobInterfaceMock.ListNamespacedFunc: method is nil but CronJobInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockCronJobInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockCronJobInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedCronJobInterface.ListNamespacedCalls())
+func (mock *CronJobInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockCronJobInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockCronJobInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *CronJobInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/batch/v1beta1/zz_generated_cron_job_controller.go

@@ -86,6 +86,7 @@ type CronJobInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*CronJobList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*CronJobList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() CronJobController
@@ -273,6 +274,11 @@ func (s *cronJobClient) List(opts metav1.ListOptions) (*CronJobList, error) {
 	return obj.(*CronJobList), err
 }
 
+func (s *cronJobClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*CronJobList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*CronJobList), err
+}
+
 func (s *cronJobClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/cluster.cattle.io/v3/fakes/zz_generated_cluster_auth_token_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterAuthTokenInterfaceMockGet                              sync.RWMutex
 	lockClusterAuthTokenInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterAuthTokenInterfaceMockList                             sync.RWMutex
+	lockClusterAuthTokenInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterAuthTokenInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterAuthTokenInterfaceMockUpdate                           sync.RWMutex
 	lockClusterAuthTokenInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterAuthTokenInterface = &ClusterAuthTokenInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterAuthTokenList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterAuthTokenList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterAuthTokenInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterAuthTokenList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterAuthTokenList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterAuthTokenInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterAuthTokenInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterAuthTokenInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterAuthTokenList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterAuthTokenInterfaceMock.ListNamespacedFunc: method is nil but ClusterAuthTokenInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterAuthTokenInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterAuthTokenInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterAuthTokenInterface.ListNamespacedCalls())
+func (mock *ClusterAuthTokenInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterAuthTokenInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterAuthTokenInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterAuthTokenInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/cluster.cattle.io/v3/fakes/zz_generated_cluster_user_attribute_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterUserAttributeInterfaceMockGet                              sync.RWMutex
 	lockClusterUserAttributeInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterUserAttributeInterfaceMockList                             sync.RWMutex
+	lockClusterUserAttributeInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterUserAttributeInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterUserAttributeInterfaceMockUpdate                           sync.RWMutex
 	lockClusterUserAttributeInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterUserAttributeInterface = &ClusterUserAttributeInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterUserAttributeList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterUserAttributeList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterUserAttributeInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterUserAttributeList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterUserAttributeList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterUserAttributeInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterUserAttributeInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterUserAttributeInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterUserAttributeList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterUserAttributeInterfaceMock.ListNamespacedFunc: method is nil but ClusterUserAttributeInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterUserAttributeInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterUserAttributeInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterUserAttributeInterface.ListNamespacedCalls())
+func (mock *ClusterUserAttributeInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterUserAttributeInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterUserAttributeInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterUserAttributeInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/cluster.cattle.io/v3/zz_generated_cluster_auth_token_controller.go

@@ -85,6 +85,7 @@ type ClusterAuthTokenInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ClusterAuthTokenList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterAuthTokenList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ClusterAuthTokenController
@@ -272,6 +273,11 @@ func (s *clusterAuthTokenClient) List(opts metav1.ListOptions) (*ClusterAuthToke
 	return obj.(*ClusterAuthTokenList), err
 }
 
+func (s *clusterAuthTokenClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterAuthTokenList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ClusterAuthTokenList), err
+}
+
 func (s *clusterAuthTokenClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/cluster.cattle.io/v3/zz_generated_cluster_user_attribute_controller.go

@@ -85,6 +85,7 @@ type ClusterUserAttributeInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ClusterUserAttributeList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterUserAttributeList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ClusterUserAttributeController
@@ -272,6 +273,11 @@ func (s *clusterUserAttributeClient) List(opts metav1.ListOptions) (*ClusterUser
 	return obj.(*ClusterUserAttributeList), err
 }
 
+func (s *clusterUserAttributeClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ClusterUserAttributeList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ClusterUserAttributeList), err
+}
+
 func (s *clusterUserAttributeClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/fakes/zz_generated_component_status_mock.go

@@ -675,6 +675,7 @@ var (
 	lockComponentStatusInterfaceMockGet                              sync.RWMutex
 	lockComponentStatusInterfaceMockGetNamespaced                    sync.RWMutex
 	lockComponentStatusInterfaceMockList                             sync.RWMutex
+	lockComponentStatusInterfaceMockListNamespaced                   sync.RWMutex
 	lockComponentStatusInterfaceMockObjectClient                     sync.RWMutex
 	lockComponentStatusInterfaceMockUpdate                           sync.RWMutex
 	lockComponentStatusInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ComponentStatusInterface = &ComponentStatusInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ComponentStatusList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ComponentStatusList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ComponentStatusInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ComponentStatusList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ComponentStatusList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ComponentStatusInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ComponentStatusInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ComponentStatusInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ComponentStatusList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ComponentStatusInterfaceMock.ListNamespacedFunc: method is nil but ComponentStatusInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockComponentStatusInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockComponentStatusInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedComponentStatusInterface.ListNamespacedCalls())
+func (mock *ComponentStatusInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockComponentStatusInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockComponentStatusInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ComponentStatusInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_config_map_mock.go

@@ -675,6 +675,7 @@ var (
 	lockConfigMapInterfaceMockGet                              sync.RWMutex
 	lockConfigMapInterfaceMockGetNamespaced                    sync.RWMutex
 	lockConfigMapInterfaceMockList                             sync.RWMutex
+	lockConfigMapInterfaceMockListNamespaced                   sync.RWMutex
 	lockConfigMapInterfaceMockObjectClient                     sync.RWMutex
 	lockConfigMapInterfaceMockUpdate                           sync.RWMutex
 	lockConfigMapInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ConfigMapInterface = &ConfigMapInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ConfigMapList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ConfigMapList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ConfigMapInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ConfigMapList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ConfigMapList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ConfigMapInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ConfigMapInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ConfigMapInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ConfigMapList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ConfigMapInterfaceMock.ListNamespacedFunc: method is nil but ConfigMapInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockConfigMapInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockConfigMapInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedConfigMapInterface.ListNamespacedCalls())
+func (mock *ConfigMapInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockConfigMapInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockConfigMapInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ConfigMapInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_endpoints_mock.go

@@ -675,6 +675,7 @@ var (
 	lockEndpointsInterfaceMockGet                              sync.RWMutex
 	lockEndpointsInterfaceMockGetNamespaced                    sync.RWMutex
 	lockEndpointsInterfaceMockList                             sync.RWMutex
+	lockEndpointsInterfaceMockListNamespaced                   sync.RWMutex
 	lockEndpointsInterfaceMockObjectClient                     sync.RWMutex
 	lockEndpointsInterfaceMockUpdate                           sync.RWMutex
 	lockEndpointsInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.EndpointsInterface = &EndpointsInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.EndpointsList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.EndpointsList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type EndpointsInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.EndpointsList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.EndpointsList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type EndpointsInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *EndpointsInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *EndpointsInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.EndpointsList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("EndpointsInterfaceMock.ListNamespacedFunc: method is nil but EndpointsInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockEndpointsInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockEndpointsInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedEndpointsInterface.ListNamespacedCalls())
+func (mock *EndpointsInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockEndpointsInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockEndpointsInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *EndpointsInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_event_mock.go

@@ -675,6 +675,7 @@ var (
 	lockEventInterfaceMockGet                              sync.RWMutex
 	lockEventInterfaceMockGetNamespaced                    sync.RWMutex
 	lockEventInterfaceMockList                             sync.RWMutex
+	lockEventInterfaceMockListNamespaced                   sync.RWMutex
 	lockEventInterfaceMockObjectClient                     sync.RWMutex
 	lockEventInterfaceMockUpdate                           sync.RWMutex
 	lockEventInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.EventInterface = &EventInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.EventList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.EventList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type EventInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.EventList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.EventList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type EventInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *EventInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *EventInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.EventList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("EventInterfaceMock.ListNamespacedFunc: method is nil but EventInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockEventInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockEventInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedEventInterface.ListNamespacedCalls())
+func (mock *EventInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockEventInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockEventInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *EventInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_limit_range_mock.go

@@ -675,6 +675,7 @@ var (
 	lockLimitRangeInterfaceMockGet                              sync.RWMutex
 	lockLimitRangeInterfaceMockGetNamespaced                    sync.RWMutex
 	lockLimitRangeInterfaceMockList                             sync.RWMutex
+	lockLimitRangeInterfaceMockListNamespaced                   sync.RWMutex
 	lockLimitRangeInterfaceMockObjectClient                     sync.RWMutex
 	lockLimitRangeInterfaceMockUpdate                           sync.RWMutex
 	lockLimitRangeInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.LimitRangeInterface = &LimitRangeInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.LimitRangeList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.LimitRangeList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type LimitRangeInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.LimitRangeList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.LimitRangeList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type LimitRangeInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *LimitRangeInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *LimitRangeInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.LimitRangeList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("LimitRangeInterfaceMock.ListNamespacedFunc: method is nil but LimitRangeInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockLimitRangeInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockLimitRangeInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedLimitRangeInterface.ListNamespacedCalls())
+func (mock *LimitRangeInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockLimitRangeInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockLimitRangeInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *LimitRangeInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_namespace_mock.go

@@ -675,6 +675,7 @@ var (
 	lockNamespaceInterfaceMockGet                              sync.RWMutex
 	lockNamespaceInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNamespaceInterfaceMockList                             sync.RWMutex
+	lockNamespaceInterfaceMockListNamespaced                   sync.RWMutex
 	lockNamespaceInterfaceMockObjectClient                     sync.RWMutex
 	lockNamespaceInterfaceMockUpdate                           sync.RWMutex
 	lockNamespaceInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.NamespaceInterface = &NamespaceInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.NamespaceList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.NamespaceList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type NamespaceInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.NamespaceList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.NamespaceList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type NamespaceInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *NamespaceInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NamespaceInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.NamespaceList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NamespaceInterfaceMock.ListNamespacedFunc: method is nil but NamespaceInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNamespaceInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNamespaceInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNamespaceInterface.ListNamespacedCalls())
+func (mock *NamespaceInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockNamespaceInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNamespaceInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NamespaceInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_node_mock.go

@@ -675,6 +675,7 @@ var (
 	lockNodeInterfaceMockGet                              sync.RWMutex
 	lockNodeInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNodeInterfaceMockList                             sync.RWMutex
+	lockNodeInterfaceMockListNamespaced                   sync.RWMutex
 	lockNodeInterfaceMockObjectClient                     sync.RWMutex
 	lockNodeInterfaceMockUpdate                           sync.RWMutex
 	lockNodeInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.NodeInterface = &NodeInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.NodeList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.NodeList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type NodeInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.NodeList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.NodeList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type NodeInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *NodeInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NodeInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.NodeList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NodeInterfaceMock.ListNamespacedFunc: method is nil but NodeInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNodeInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNodeInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNodeInterface.ListNamespacedCalls())
+func (mock *NodeInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockNodeInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNodeInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NodeInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_persistent_volume_claim_mock.go

@@ -675,6 +675,7 @@ var (
 	lockPersistentVolumeClaimInterfaceMockGet                              sync.RWMutex
 	lockPersistentVolumeClaimInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPersistentVolumeClaimInterfaceMockList                             sync.RWMutex
+	lockPersistentVolumeClaimInterfaceMockListNamespaced                   sync.RWMutex
 	lockPersistentVolumeClaimInterfaceMockObjectClient                     sync.RWMutex
 	lockPersistentVolumeClaimInterfaceMockUpdate                           sync.RWMutex
 	lockPersistentVolumeClaimInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.PersistentVolumeClaimInterface = &PersistentVolumeClaimInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.PersistentVolumeClaimList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.PersistentVolumeClaimList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type PersistentVolumeClaimInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.PersistentVolumeClaimList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.PersistentVolumeClaimList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type PersistentVolumeClaimInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *PersistentVolumeClaimInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PersistentVolumeClaimInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.PersistentVolumeClaimList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PersistentVolumeClaimInterfaceMock.ListNamespacedFunc: method is nil but PersistentVolumeClaimInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPersistentVolumeClaimInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPersistentVolumeClaimInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPersistentVolumeClaimInterface.ListNamespacedCalls())
+func (mock *PersistentVolumeClaimInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockPersistentVolumeClaimInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPersistentVolumeClaimInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PersistentVolumeClaimInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_pod_mock.go

@@ -675,6 +675,7 @@ var (
 	lockPodInterfaceMockGet                              sync.RWMutex
 	lockPodInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPodInterfaceMockList                             sync.RWMutex
+	lockPodInterfaceMockListNamespaced                   sync.RWMutex
 	lockPodInterfaceMockObjectClient                     sync.RWMutex
 	lockPodInterfaceMockUpdate                           sync.RWMutex
 	lockPodInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.PodInterface = &PodInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.PodList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.PodList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type PodInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.PodList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.PodList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type PodInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *PodInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PodInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.PodList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PodInterfaceMock.ListNamespacedFunc: method is nil but PodInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPodInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPodInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPodInterface.ListNamespacedCalls())
+func (mock *PodInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockPodInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPodInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PodInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_replication_controller_mock.go

@@ -675,6 +675,7 @@ var (
 	lockReplicationControllerInterfaceMockGet                              sync.RWMutex
 	lockReplicationControllerInterfaceMockGetNamespaced                    sync.RWMutex
 	lockReplicationControllerInterfaceMockList                             sync.RWMutex
+	lockReplicationControllerInterfaceMockListNamespaced                   sync.RWMutex
 	lockReplicationControllerInterfaceMockObjectClient                     sync.RWMutex
 	lockReplicationControllerInterfaceMockUpdate                           sync.RWMutex
 	lockReplicationControllerInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ReplicationControllerInterface = &ReplicationControllerInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ReplicationControllerList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ReplicationControllerList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ReplicationControllerInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ReplicationControllerList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ReplicationControllerList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ReplicationControllerInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ReplicationControllerInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ReplicationControllerInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ReplicationControllerList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ReplicationControllerInterfaceMock.ListNamespacedFunc: method is nil but ReplicationControllerInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockReplicationControllerInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockReplicationControllerInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedReplicationControllerInterface.ListNamespacedCalls())
+func (mock *ReplicationControllerInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockReplicationControllerInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockReplicationControllerInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ReplicationControllerInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_resource_quota_mock.go

@@ -675,6 +675,7 @@ var (
 	lockResourceQuotaInterfaceMockGet                              sync.RWMutex
 	lockResourceQuotaInterfaceMockGetNamespaced                    sync.RWMutex
 	lockResourceQuotaInterfaceMockList                             sync.RWMutex
+	lockResourceQuotaInterfaceMockListNamespaced                   sync.RWMutex
 	lockResourceQuotaInterfaceMockObjectClient                     sync.RWMutex
 	lockResourceQuotaInterfaceMockUpdate                           sync.RWMutex
 	lockResourceQuotaInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ResourceQuotaInterface = &ResourceQuotaInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ResourceQuotaList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ResourceQuotaList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ResourceQuotaInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ResourceQuotaList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ResourceQuotaList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ResourceQuotaInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ResourceQuotaInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ResourceQuotaInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ResourceQuotaList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ResourceQuotaInterfaceMock.ListNamespacedFunc: method is nil but ResourceQuotaInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockResourceQuotaInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockResourceQuotaInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedResourceQuotaInterface.ListNamespacedCalls())
+func (mock *ResourceQuotaInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockResourceQuotaInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockResourceQuotaInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ResourceQuotaInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_secret_mock.go

@@ -675,6 +675,7 @@ var (
 	lockSecretInterfaceMockGet                              sync.RWMutex
 	lockSecretInterfaceMockGetNamespaced                    sync.RWMutex
 	lockSecretInterfaceMockList                             sync.RWMutex
+	lockSecretInterfaceMockListNamespaced                   sync.RWMutex
 	lockSecretInterfaceMockObjectClient                     sync.RWMutex
 	lockSecretInterfaceMockUpdate                           sync.RWMutex
 	lockSecretInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.SecretInterface = &SecretInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.SecretList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type SecretInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.SecretList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type SecretInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *SecretInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *SecretInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("SecretInterfaceMock.ListNamespacedFunc: method is nil but SecretInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockSecretInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockSecretInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedSecretInterface.ListNamespacedCalls())
+func (mock *SecretInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockSecretInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockSecretInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *SecretInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_service_account_mock.go

@@ -675,6 +675,7 @@ var (
 	lockServiceAccountInterfaceMockGet                              sync.RWMutex
 	lockServiceAccountInterfaceMockGetNamespaced                    sync.RWMutex
 	lockServiceAccountInterfaceMockList                             sync.RWMutex
+	lockServiceAccountInterfaceMockListNamespaced                   sync.RWMutex
 	lockServiceAccountInterfaceMockObjectClient                     sync.RWMutex
 	lockServiceAccountInterfaceMockUpdate                           sync.RWMutex
 	lockServiceAccountInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ServiceAccountInterface = &ServiceAccountInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ServiceAccountList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ServiceAccountList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ServiceAccountInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ServiceAccountList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ServiceAccountList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ServiceAccountInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ServiceAccountInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ServiceAccountInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ServiceAccountList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ServiceAccountInterfaceMock.ListNamespacedFunc: method is nil but ServiceAccountInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockServiceAccountInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockServiceAccountInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedServiceAccountInterface.ListNamespacedCalls())
+func (mock *ServiceAccountInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockServiceAccountInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockServiceAccountInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ServiceAccountInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/fakes/zz_generated_service_mock.go

@@ -675,6 +675,7 @@ var (
 	lockServiceInterfaceMockGet                              sync.RWMutex
 	lockServiceInterfaceMockGetNamespaced                    sync.RWMutex
 	lockServiceInterfaceMockList                             sync.RWMutex
+	lockServiceInterfaceMockListNamespaced                   sync.RWMutex
 	lockServiceInterfaceMockObjectClient                     sync.RWMutex
 	lockServiceInterfaceMockUpdate                           sync.RWMutex
 	lockServiceInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1a.ServiceInterface = &ServiceInterfaceMock{}
 //             ListFunc: func(opts v1b.ListOptions) (*v1a.ServiceList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1b.ListOptions) (*v1a.ServiceList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type ServiceInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1b.ListOptions) (*v1a.ServiceList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1b.ListOptions) (*v1a.ServiceList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type ServiceInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1b.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1b.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *ServiceInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ServiceInterfaceMock) ListNamespaced(namespace string, opts v1b.ListOptions) (*v1a.ServiceList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ServiceInterfaceMock.ListNamespacedFunc: method is nil but ServiceInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockServiceInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockServiceInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedServiceInterface.ListNamespacedCalls())
+func (mock *ServiceInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1b.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1b.ListOptions
+	}
+	lockServiceInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockServiceInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ServiceInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/core/v1/zz_generated_component_status_controller.go

@@ -85,6 +85,7 @@ type ComponentStatusInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ComponentStatusList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ComponentStatusList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ComponentStatusController
@@ -272,6 +273,11 @@ func (s *componentStatusClient) List(opts metav1.ListOptions) (*ComponentStatusL
 	return obj.(*ComponentStatusList), err
 }
 
+func (s *componentStatusClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ComponentStatusList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ComponentStatusList), err
+}
+
 func (s *componentStatusClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_config_map_controller.go

@@ -86,6 +86,7 @@ type ConfigMapInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ConfigMapList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ConfigMapList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ConfigMapController
@@ -273,6 +274,11 @@ func (s *configMapClient) List(opts metav1.ListOptions) (*ConfigMapList, error)
 	return obj.(*ConfigMapList), err
 }
 
+func (s *configMapClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ConfigMapList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ConfigMapList), err
+}
+
 func (s *configMapClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_endpoints_controller.go

@@ -86,6 +86,7 @@ type EndpointsInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*EndpointsList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*EndpointsList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() EndpointsController
@@ -273,6 +274,11 @@ func (s *endpointsClient) List(opts metav1.ListOptions) (*EndpointsList, error)
 	return obj.(*EndpointsList), err
 }
 
+func (s *endpointsClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*EndpointsList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*EndpointsList), err
+}
+
 func (s *endpointsClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_event_controller.go

@@ -85,6 +85,7 @@ type EventInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*EventList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*EventList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() EventController
@@ -272,6 +273,11 @@ func (s *eventClient) List(opts metav1.ListOptions) (*EventList, error) {
 	return obj.(*EventList), err
 }
 
+func (s *eventClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*EventList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*EventList), err
+}
+
 func (s *eventClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_limit_range_controller.go

@@ -86,6 +86,7 @@ type LimitRangeInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*LimitRangeList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*LimitRangeList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() LimitRangeController
@@ -273,6 +274,11 @@ func (s *limitRangeClient) List(opts metav1.ListOptions) (*LimitRangeList, error
 	return obj.(*LimitRangeList), err
 }
 
+func (s *limitRangeClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*LimitRangeList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*LimitRangeList), err
+}
+
 func (s *limitRangeClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_namespace_controller.go

@@ -85,6 +85,7 @@ type NamespaceInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*NamespaceList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*NamespaceList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() NamespaceController
@@ -272,6 +273,11 @@ func (s *namespaceClient) List(opts metav1.ListOptions) (*NamespaceList, error)
 	return obj.(*NamespaceList), err
 }
 
+func (s *namespaceClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*NamespaceList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*NamespaceList), err
+}
+
 func (s *namespaceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_node_controller.go

@@ -85,6 +85,7 @@ type NodeInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*NodeList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodeList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() NodeController
@@ -272,6 +273,11 @@ func (s *nodeClient) List(opts metav1.ListOptions) (*NodeList, error) {
 	return obj.(*NodeList), err
 }
 
+func (s *nodeClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*NodeList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*NodeList), err
+}
+
 func (s *nodeClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_persistent_volume_claim_controller.go

@@ -86,6 +86,7 @@ type PersistentVolumeClaimInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*PersistentVolumeClaimList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*PersistentVolumeClaimList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() PersistentVolumeClaimController
@@ -273,6 +274,11 @@ func (s *persistentVolumeClaimClient) List(opts metav1.ListOptions) (*Persistent
 	return obj.(*PersistentVolumeClaimList), err
 }
 
+func (s *persistentVolumeClaimClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*PersistentVolumeClaimList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*PersistentVolumeClaimList), err
+}
+
 func (s *persistentVolumeClaimClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_pod_controller.go

@@ -86,6 +86,7 @@ type PodInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*PodList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*PodList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() PodController
@@ -273,6 +274,11 @@ func (s *podClient) List(opts metav1.ListOptions) (*PodList, error) {
 	return obj.(*PodList), err
 }
 
+func (s *podClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*PodList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*PodList), err
+}
+
 func (s *podClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_replication_controller_controller.go

@@ -86,6 +86,7 @@ type ReplicationControllerInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ReplicationControllerList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ReplicationControllerList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ReplicationControllerController
@@ -273,6 +274,11 @@ func (s *replicationControllerClient) List(opts metav1.ListOptions) (*Replicatio
 	return obj.(*ReplicationControllerList), err
 }
 
+func (s *replicationControllerClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ReplicationControllerList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ReplicationControllerList), err
+}
+
 func (s *replicationControllerClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_resource_quota_controller.go

@@ -86,6 +86,7 @@ type ResourceQuotaInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ResourceQuotaList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ResourceQuotaList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ResourceQuotaController
@@ -273,6 +274,11 @@ func (s *resourceQuotaClient) List(opts metav1.ListOptions) (*ResourceQuotaList,
 	return obj.(*ResourceQuotaList), err
 }
 
+func (s *resourceQuotaClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ResourceQuotaList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ResourceQuotaList), err
+}
+
 func (s *resourceQuotaClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_secret_controller.go

@@ -86,6 +86,7 @@ type SecretInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*SecretList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*SecretList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() SecretController
@@ -273,6 +274,11 @@ func (s *secretClient) List(opts metav1.ListOptions) (*SecretList, error) {
 	return obj.(*SecretList), err
 }
 
+func (s *secretClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*SecretList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*SecretList), err
+}
+
 func (s *secretClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_service_account_controller.go

@@ -86,6 +86,7 @@ type ServiceAccountInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ServiceAccountList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ServiceAccountList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ServiceAccountController
@@ -273,6 +274,11 @@ func (s *serviceAccountClient) List(opts metav1.ListOptions) (*ServiceAccountLis
 	return obj.(*ServiceAccountList), err
 }
 
+func (s *serviceAccountClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ServiceAccountList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ServiceAccountList), err
+}
+
 func (s *serviceAccountClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/core/v1/zz_generated_service_controller.go

@@ -86,6 +86,7 @@ type ServiceInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*ServiceList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*ServiceList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() ServiceController
@@ -273,6 +274,11 @@ func (s *serviceClient) List(opts metav1.ListOptions) (*ServiceList, error) {
 	return obj.(*ServiceList), err
 }
 
+func (s *serviceClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*ServiceList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*ServiceList), err
+}
+
 func (s *serviceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/extensions/v1beta1/fakes/zz_generated_ingress_mock.go

@@ -675,6 +675,7 @@ var (
 	lockIngressInterfaceMockGet                              sync.RWMutex
 	lockIngressInterfaceMockGetNamespaced                    sync.RWMutex
 	lockIngressInterfaceMockList                             sync.RWMutex
+	lockIngressInterfaceMockListNamespaced                   sync.RWMutex
 	lockIngressInterfaceMockObjectClient                     sync.RWMutex
 	lockIngressInterfaceMockUpdate                           sync.RWMutex
 	lockIngressInterfaceMockWatch                            sync.RWMutex
@@ -738,6 +739,9 @@ var _ v1beta1a.IngressInterface = &IngressInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v1beta1a.IngressList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v1beta1a.IngressList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -802,6 +806,9 @@ type IngressInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v1beta1a.IngressList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v1beta1a.IngressList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -953,6 +960,13 @@ type IngressInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1584,6 +1598,41 @@ func (mock *IngressInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *IngressInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v1beta1a.IngressList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("IngressInterfaceMock.ListNamespacedFunc: method is nil but IngressInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockIngressInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockIngressInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedIngressInterface.ListNamespacedCalls())
+func (mock *IngressInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockIngressInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockIngressInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *IngressInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/extensions/v1beta1/zz_generated_ingress_controller.go

@@ -86,6 +86,7 @@ type IngressInterface interface {
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
 	List(opts metav1.ListOptions) (*IngressList, error)
+	ListNamespaced(namespace string, opts metav1.ListOptions) (*IngressList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
 	Controller() IngressController
@@ -273,6 +274,11 @@ func (s *ingressClient) List(opts metav1.ListOptions) (*IngressList, error) {
 	return obj.(*IngressList), err
 }
 
+func (s *ingressClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*IngressList, error) {
+	obj, err := s.objectClient.ListNamespaced(namespace, opts)
+	return obj.(*IngressList), err
+}
+
 func (s *ingressClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }

apis/management.cattle.io/v3/fakes/zz_generated_auth_config_mock.go

@@ -674,6 +674,7 @@ var (
 	lockAuthConfigInterfaceMockGet                              sync.RWMutex
 	lockAuthConfigInterfaceMockGetNamespaced                    sync.RWMutex
 	lockAuthConfigInterfaceMockList                             sync.RWMutex
+	lockAuthConfigInterfaceMockListNamespaced                   sync.RWMutex
 	lockAuthConfigInterfaceMockObjectClient                     sync.RWMutex
 	lockAuthConfigInterfaceMockUpdate                           sync.RWMutex
 	lockAuthConfigInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.AuthConfigInterface = &AuthConfigInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.AuthConfigList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.AuthConfigList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type AuthConfigInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.AuthConfigList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.AuthConfigList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type AuthConfigInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *AuthConfigInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *AuthConfigInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.AuthConfigList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("AuthConfigInterfaceMock.ListNamespacedFunc: method is nil but AuthConfigInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockAuthConfigInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockAuthConfigInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedAuthConfigInterface.ListNamespacedCalls())
+func (mock *AuthConfigInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockAuthConfigInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockAuthConfigInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *AuthConfigInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_catalog_mock.go

@@ -674,6 +674,7 @@ var (
 	lockCatalogInterfaceMockGet                              sync.RWMutex
 	lockCatalogInterfaceMockGetNamespaced                    sync.RWMutex
 	lockCatalogInterfaceMockList                             sync.RWMutex
+	lockCatalogInterfaceMockListNamespaced                   sync.RWMutex
 	lockCatalogInterfaceMockObjectClient                     sync.RWMutex
 	lockCatalogInterfaceMockUpdate                           sync.RWMutex
 	lockCatalogInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.CatalogInterface = &CatalogInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.CatalogList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.CatalogList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type CatalogInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.CatalogList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.CatalogList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type CatalogInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *CatalogInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *CatalogInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.CatalogList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("CatalogInterfaceMock.ListNamespacedFunc: method is nil but CatalogInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockCatalogInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockCatalogInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedCatalogInterface.ListNamespacedCalls())
+func (mock *CatalogInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockCatalogInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockCatalogInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *CatalogInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_catalog_template_mock.go

@@ -674,6 +674,7 @@ var (
 	lockCatalogTemplateInterfaceMockGet                              sync.RWMutex
 	lockCatalogTemplateInterfaceMockGetNamespaced                    sync.RWMutex
 	lockCatalogTemplateInterfaceMockList                             sync.RWMutex
+	lockCatalogTemplateInterfaceMockListNamespaced                   sync.RWMutex
 	lockCatalogTemplateInterfaceMockObjectClient                     sync.RWMutex
 	lockCatalogTemplateInterfaceMockUpdate                           sync.RWMutex
 	lockCatalogTemplateInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.CatalogTemplateInterface = &CatalogTemplateInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.CatalogTemplateList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type CatalogTemplateInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.CatalogTemplateList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type CatalogTemplateInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *CatalogTemplateInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *CatalogTemplateInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("CatalogTemplateInterfaceMock.ListNamespacedFunc: method is nil but CatalogTemplateInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockCatalogTemplateInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockCatalogTemplateInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedCatalogTemplateInterface.ListNamespacedCalls())
+func (mock *CatalogTemplateInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockCatalogTemplateInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockCatalogTemplateInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *CatalogTemplateInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_catalog_template_version_mock.go

@@ -674,6 +674,7 @@ var (
 	lockCatalogTemplateVersionInterfaceMockGet                              sync.RWMutex
 	lockCatalogTemplateVersionInterfaceMockGetNamespaced                    sync.RWMutex
 	lockCatalogTemplateVersionInterfaceMockList                             sync.RWMutex
+	lockCatalogTemplateVersionInterfaceMockListNamespaced                   sync.RWMutex
 	lockCatalogTemplateVersionInterfaceMockObjectClient                     sync.RWMutex
 	lockCatalogTemplateVersionInterfaceMockUpdate                           sync.RWMutex
 	lockCatalogTemplateVersionInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.CatalogTemplateVersionInterface = &CatalogTemplateVersionInterfaceMock{
 //             ListFunc: func(opts v1.ListOptions) (*v3.CatalogTemplateVersionList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateVersionList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type CatalogTemplateVersionInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.CatalogTemplateVersionList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateVersionList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type CatalogTemplateVersionInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *CatalogTemplateVersionInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *CatalogTemplateVersionInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.CatalogTemplateVersionList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("CatalogTemplateVersionInterfaceMock.ListNamespacedFunc: method is nil but CatalogTemplateVersionInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockCatalogTemplateVersionInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockCatalogTemplateVersionInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedCatalogTemplateVersionInterface.ListNamespacedCalls())
+func (mock *CatalogTemplateVersionInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockCatalogTemplateVersionInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockCatalogTemplateVersionInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *CatalogTemplateVersionInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cloud_credential_mock.go

@@ -674,6 +674,7 @@ var (
 	lockCloudCredentialInterfaceMockGet                              sync.RWMutex
 	lockCloudCredentialInterfaceMockGetNamespaced                    sync.RWMutex
 	lockCloudCredentialInterfaceMockList                             sync.RWMutex
+	lockCloudCredentialInterfaceMockListNamespaced                   sync.RWMutex
 	lockCloudCredentialInterfaceMockObjectClient                     sync.RWMutex
 	lockCloudCredentialInterfaceMockUpdate                           sync.RWMutex
 	lockCloudCredentialInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.CloudCredentialInterface = &CloudCredentialInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.CloudCredentialList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.CloudCredentialList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type CloudCredentialInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.CloudCredentialList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.CloudCredentialList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type CloudCredentialInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *CloudCredentialInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *CloudCredentialInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.CloudCredentialList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("CloudCredentialInterfaceMock.ListNamespacedFunc: method is nil but CloudCredentialInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockCloudCredentialInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockCloudCredentialInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedCloudCredentialInterface.ListNamespacedCalls())
+func (mock *CloudCredentialInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockCloudCredentialInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockCloudCredentialInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *CloudCredentialInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_alert_group_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterAlertGroupInterfaceMockGet                              sync.RWMutex
 	lockClusterAlertGroupInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterAlertGroupInterfaceMockList                             sync.RWMutex
+	lockClusterAlertGroupInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterAlertGroupInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterAlertGroupInterfaceMockUpdate                           sync.RWMutex
 	lockClusterAlertGroupInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterAlertGroupInterface = &ClusterAlertGroupInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterAlertGroupList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertGroupList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterAlertGroupInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterAlertGroupList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertGroupList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterAlertGroupInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterAlertGroupInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterAlertGroupInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterAlertGroupList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterAlertGroupInterfaceMock.ListNamespacedFunc: method is nil but ClusterAlertGroupInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterAlertGroupInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterAlertGroupInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterAlertGroupInterface.ListNamespacedCalls())
+func (mock *ClusterAlertGroupInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterAlertGroupInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterAlertGroupInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterAlertGroupInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_alert_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterAlertInterfaceMockGet                              sync.RWMutex
 	lockClusterAlertInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterAlertInterfaceMockList                             sync.RWMutex
+	lockClusterAlertInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterAlertInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterAlertInterfaceMockUpdate                           sync.RWMutex
 	lockClusterAlertInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterAlertInterface = &ClusterAlertInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterAlertList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterAlertInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterAlertList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterAlertInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterAlertInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterAlertInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterAlertList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterAlertInterfaceMock.ListNamespacedFunc: method is nil but ClusterAlertInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterAlertInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterAlertInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterAlertInterface.ListNamespacedCalls())
+func (mock *ClusterAlertInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterAlertInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterAlertInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterAlertInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_alert_rule_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterAlertRuleInterfaceMockGet                              sync.RWMutex
 	lockClusterAlertRuleInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterAlertRuleInterfaceMockList                             sync.RWMutex
+	lockClusterAlertRuleInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterAlertRuleInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterAlertRuleInterfaceMockUpdate                           sync.RWMutex
 	lockClusterAlertRuleInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterAlertRuleInterface = &ClusterAlertRuleInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterAlertRuleList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertRuleList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterAlertRuleInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterAlertRuleList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterAlertRuleList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterAlertRuleInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterAlertRuleInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterAlertRuleInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterAlertRuleList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterAlertRuleInterfaceMock.ListNamespacedFunc: method is nil but ClusterAlertRuleInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterAlertRuleInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterAlertRuleInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterAlertRuleInterface.ListNamespacedCalls())
+func (mock *ClusterAlertRuleInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterAlertRuleInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterAlertRuleInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterAlertRuleInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_catalog_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterCatalogInterfaceMockGet                              sync.RWMutex
 	lockClusterCatalogInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterCatalogInterfaceMockList                             sync.RWMutex
+	lockClusterCatalogInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterCatalogInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterCatalogInterfaceMockUpdate                           sync.RWMutex
 	lockClusterCatalogInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterCatalogInterface = &ClusterCatalogInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterCatalogList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterCatalogList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterCatalogInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterCatalogList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterCatalogList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterCatalogInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterCatalogInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterCatalogInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterCatalogList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterCatalogInterfaceMock.ListNamespacedFunc: method is nil but ClusterCatalogInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterCatalogInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterCatalogInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterCatalogInterface.ListNamespacedCalls())
+func (mock *ClusterCatalogInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterCatalogInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterCatalogInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterCatalogInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_logging_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterLoggingInterfaceMockGet                              sync.RWMutex
 	lockClusterLoggingInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterLoggingInterfaceMockList                             sync.RWMutex
+	lockClusterLoggingInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterLoggingInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterLoggingInterfaceMockUpdate                           sync.RWMutex
 	lockClusterLoggingInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterLoggingInterface = &ClusterLoggingInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterLoggingList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterLoggingList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterLoggingInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterLoggingList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterLoggingList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterLoggingInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterLoggingInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterLoggingInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterLoggingList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterLoggingInterfaceMock.ListNamespacedFunc: method is nil but ClusterLoggingInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterLoggingInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterLoggingInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterLoggingInterface.ListNamespacedCalls())
+func (mock *ClusterLoggingInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterLoggingInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterLoggingInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterLoggingInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterInterfaceMockGet                              sync.RWMutex
 	lockClusterInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterInterfaceMockList                             sync.RWMutex
+	lockClusterInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterInterfaceMockUpdate                           sync.RWMutex
 	lockClusterInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterInterface = &ClusterInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterInterfaceMock.ListNamespacedFunc: method is nil but ClusterInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterInterface.ListNamespacedCalls())
+func (mock *ClusterInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_monitor_graph_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterMonitorGraphInterfaceMockGet                              sync.RWMutex
 	lockClusterMonitorGraphInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterMonitorGraphInterfaceMockList                             sync.RWMutex
+	lockClusterMonitorGraphInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterMonitorGraphInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterMonitorGraphInterfaceMockUpdate                           sync.RWMutex
 	lockClusterMonitorGraphInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterMonitorGraphInterface = &ClusterMonitorGraphInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterMonitorGraphList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterMonitorGraphList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterMonitorGraphInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterMonitorGraphList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterMonitorGraphList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterMonitorGraphInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterMonitorGraphInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterMonitorGraphInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterMonitorGraphList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterMonitorGraphInterfaceMock.ListNamespacedFunc: method is nil but ClusterMonitorGraphInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterMonitorGraphInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterMonitorGraphInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterMonitorGraphInterface.ListNamespacedCalls())
+func (mock *ClusterMonitorGraphInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterMonitorGraphInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterMonitorGraphInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterMonitorGraphInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_registration_token_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterRegistrationTokenInterfaceMockGet                              sync.RWMutex
 	lockClusterRegistrationTokenInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterRegistrationTokenInterfaceMockList                             sync.RWMutex
+	lockClusterRegistrationTokenInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterRegistrationTokenInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterRegistrationTokenInterfaceMockUpdate                           sync.RWMutex
 	lockClusterRegistrationTokenInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterRegistrationTokenInterface = &ClusterRegistrationTokenInterfaceM
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterRegistrationTokenList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterRegistrationTokenList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterRegistrationTokenInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterRegistrationTokenList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterRegistrationTokenList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterRegistrationTokenInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterRegistrationTokenInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterRegistrationTokenInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterRegistrationTokenList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterRegistrationTokenInterfaceMock.ListNamespacedFunc: method is nil but ClusterRegistrationTokenInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterRegistrationTokenInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterRegistrationTokenInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterRegistrationTokenInterface.ListNamespacedCalls())
+func (mock *ClusterRegistrationTokenInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterRegistrationTokenInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterRegistrationTokenInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterRegistrationTokenInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_role_template_binding_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterRoleTemplateBindingInterfaceMockGet                              sync.RWMutex
 	lockClusterRoleTemplateBindingInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterRoleTemplateBindingInterfaceMockList                             sync.RWMutex
+	lockClusterRoleTemplateBindingInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterRoleTemplateBindingInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterRoleTemplateBindingInterfaceMockUpdate                           sync.RWMutex
 	lockClusterRoleTemplateBindingInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterRoleTemplateBindingInterface = &ClusterRoleTemplateBindingInterf
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterRoleTemplateBindingList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterRoleTemplateBindingList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterRoleTemplateBindingInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterRoleTemplateBindingList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterRoleTemplateBindingList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterRoleTemplateBindingInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterRoleTemplateBindingInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterRoleTemplateBindingInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterRoleTemplateBindingList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterRoleTemplateBindingInterfaceMock.ListNamespacedFunc: method is nil but ClusterRoleTemplateBindingInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterRoleTemplateBindingInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterRoleTemplateBindingInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterRoleTemplateBindingInterface.ListNamespacedCalls())
+func (mock *ClusterRoleTemplateBindingInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterRoleTemplateBindingInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterRoleTemplateBindingInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterRoleTemplateBindingInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_scan_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterScanInterfaceMockGet                              sync.RWMutex
 	lockClusterScanInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterScanInterfaceMockList                             sync.RWMutex
+	lockClusterScanInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterScanInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterScanInterfaceMockUpdate                           sync.RWMutex
 	lockClusterScanInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterScanInterface = &ClusterScanInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterScanList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterScanList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterScanInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterScanList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterScanList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterScanInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterScanInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterScanInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterScanList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterScanInterfaceMock.ListNamespacedFunc: method is nil but ClusterScanInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterScanInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterScanInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterScanInterface.ListNamespacedCalls())
+func (mock *ClusterScanInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterScanInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterScanInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterScanInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_template_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterTemplateInterfaceMockGet                              sync.RWMutex
 	lockClusterTemplateInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterTemplateInterfaceMockList                             sync.RWMutex
+	lockClusterTemplateInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterTemplateInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterTemplateInterfaceMockUpdate                           sync.RWMutex
 	lockClusterTemplateInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterTemplateInterface = &ClusterTemplateInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterTemplateList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterTemplateInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterTemplateList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterTemplateInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterTemplateInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterTemplateInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterTemplateInterfaceMock.ListNamespacedFunc: method is nil but ClusterTemplateInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterTemplateInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterTemplateInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterTemplateInterface.ListNamespacedCalls())
+func (mock *ClusterTemplateInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterTemplateInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterTemplateInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterTemplateInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_cluster_template_revision_mock.go

@@ -674,6 +674,7 @@ var (
 	lockClusterTemplateRevisionInterfaceMockGet                              sync.RWMutex
 	lockClusterTemplateRevisionInterfaceMockGetNamespaced                    sync.RWMutex
 	lockClusterTemplateRevisionInterfaceMockList                             sync.RWMutex
+	lockClusterTemplateRevisionInterfaceMockListNamespaced                   sync.RWMutex
 	lockClusterTemplateRevisionInterfaceMockObjectClient                     sync.RWMutex
 	lockClusterTemplateRevisionInterfaceMockUpdate                           sync.RWMutex
 	lockClusterTemplateRevisionInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ClusterTemplateRevisionInterface = &ClusterTemplateRevisionInterfaceMoc
 //             ListFunc: func(opts v1.ListOptions) (*v3.ClusterTemplateRevisionList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateRevisionList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ClusterTemplateRevisionInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ClusterTemplateRevisionList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateRevisionList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ClusterTemplateRevisionInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ClusterTemplateRevisionInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ClusterTemplateRevisionInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ClusterTemplateRevisionList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ClusterTemplateRevisionInterfaceMock.ListNamespacedFunc: method is nil but ClusterTemplateRevisionInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockClusterTemplateRevisionInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockClusterTemplateRevisionInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedClusterTemplateRevisionInterface.ListNamespacedCalls())
+func (mock *ClusterTemplateRevisionInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockClusterTemplateRevisionInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockClusterTemplateRevisionInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ClusterTemplateRevisionInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_compose_config_mock.go

@@ -674,6 +674,7 @@ var (
 	lockComposeConfigInterfaceMockGet                              sync.RWMutex
 	lockComposeConfigInterfaceMockGetNamespaced                    sync.RWMutex
 	lockComposeConfigInterfaceMockList                             sync.RWMutex
+	lockComposeConfigInterfaceMockListNamespaced                   sync.RWMutex
 	lockComposeConfigInterfaceMockObjectClient                     sync.RWMutex
 	lockComposeConfigInterfaceMockUpdate                           sync.RWMutex
 	lockComposeConfigInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ComposeConfigInterface = &ComposeConfigInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ComposeConfigList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ComposeConfigList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ComposeConfigInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ComposeConfigList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ComposeConfigList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ComposeConfigInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ComposeConfigInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ComposeConfigInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ComposeConfigList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ComposeConfigInterfaceMock.ListNamespacedFunc: method is nil but ComposeConfigInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockComposeConfigInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockComposeConfigInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedComposeConfigInterface.ListNamespacedCalls())
+func (mock *ComposeConfigInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockComposeConfigInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockComposeConfigInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ComposeConfigInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_dynamic_schema_mock.go

@@ -674,6 +674,7 @@ var (
 	lockDynamicSchemaInterfaceMockGet                              sync.RWMutex
 	lockDynamicSchemaInterfaceMockGetNamespaced                    sync.RWMutex
 	lockDynamicSchemaInterfaceMockList                             sync.RWMutex
+	lockDynamicSchemaInterfaceMockListNamespaced                   sync.RWMutex
 	lockDynamicSchemaInterfaceMockObjectClient                     sync.RWMutex
 	lockDynamicSchemaInterfaceMockUpdate                           sync.RWMutex
 	lockDynamicSchemaInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.DynamicSchemaInterface = &DynamicSchemaInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.DynamicSchemaList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.DynamicSchemaList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type DynamicSchemaInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.DynamicSchemaList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.DynamicSchemaList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type DynamicSchemaInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *DynamicSchemaInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *DynamicSchemaInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.DynamicSchemaList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("DynamicSchemaInterfaceMock.ListNamespacedFunc: method is nil but DynamicSchemaInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockDynamicSchemaInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockDynamicSchemaInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedDynamicSchemaInterface.ListNamespacedCalls())
+func (mock *DynamicSchemaInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockDynamicSchemaInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockDynamicSchemaInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *DynamicSchemaInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_etcd_backup_mock.go

@@ -674,6 +674,7 @@ var (
 	lockEtcdBackupInterfaceMockGet                              sync.RWMutex
 	lockEtcdBackupInterfaceMockGetNamespaced                    sync.RWMutex
 	lockEtcdBackupInterfaceMockList                             sync.RWMutex
+	lockEtcdBackupInterfaceMockListNamespaced                   sync.RWMutex
 	lockEtcdBackupInterfaceMockObjectClient                     sync.RWMutex
 	lockEtcdBackupInterfaceMockUpdate                           sync.RWMutex
 	lockEtcdBackupInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.EtcdBackupInterface = &EtcdBackupInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.EtcdBackupList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.EtcdBackupList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type EtcdBackupInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.EtcdBackupList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.EtcdBackupList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type EtcdBackupInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *EtcdBackupInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *EtcdBackupInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.EtcdBackupList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("EtcdBackupInterfaceMock.ListNamespacedFunc: method is nil but EtcdBackupInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockEtcdBackupInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockEtcdBackupInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedEtcdBackupInterface.ListNamespacedCalls())
+func (mock *EtcdBackupInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockEtcdBackupInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockEtcdBackupInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *EtcdBackupInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_feature_mock.go

@@ -674,6 +674,7 @@ var (
 	lockFeatureInterfaceMockGet                              sync.RWMutex
 	lockFeatureInterfaceMockGetNamespaced                    sync.RWMutex
 	lockFeatureInterfaceMockList                             sync.RWMutex
+	lockFeatureInterfaceMockListNamespaced                   sync.RWMutex
 	lockFeatureInterfaceMockObjectClient                     sync.RWMutex
 	lockFeatureInterfaceMockUpdate                           sync.RWMutex
 	lockFeatureInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.FeatureInterface = &FeatureInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.FeatureList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.FeatureList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type FeatureInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.FeatureList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.FeatureList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type FeatureInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *FeatureInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *FeatureInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.FeatureList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("FeatureInterfaceMock.ListNamespacedFunc: method is nil but FeatureInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockFeatureInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockFeatureInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedFeatureInterface.ListNamespacedCalls())
+func (mock *FeatureInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockFeatureInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockFeatureInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *FeatureInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_global_dns_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGlobalDNSInterfaceMockGet                              sync.RWMutex
 	lockGlobalDNSInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGlobalDNSInterfaceMockList                             sync.RWMutex
+	lockGlobalDNSInterfaceMockListNamespaced                   sync.RWMutex
 	lockGlobalDNSInterfaceMockObjectClient                     sync.RWMutex
 	lockGlobalDNSInterfaceMockUpdate                           sync.RWMutex
 	lockGlobalDNSInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GlobalDNSInterface = &GlobalDNSInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GlobalDNSList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GlobalDNSList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GlobalDNSInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GlobalDNSList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GlobalDNSList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GlobalDNSInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GlobalDNSInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GlobalDNSInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GlobalDNSList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GlobalDNSInterfaceMock.ListNamespacedFunc: method is nil but GlobalDNSInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGlobalDNSInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGlobalDNSInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGlobalDNSInterface.ListNamespacedCalls())
+func (mock *GlobalDNSInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGlobalDNSInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGlobalDNSInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GlobalDNSInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_global_dns_provider_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGlobalDNSProviderInterfaceMockGet                              sync.RWMutex
 	lockGlobalDNSProviderInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGlobalDNSProviderInterfaceMockList                             sync.RWMutex
+	lockGlobalDNSProviderInterfaceMockListNamespaced                   sync.RWMutex
 	lockGlobalDNSProviderInterfaceMockObjectClient                     sync.RWMutex
 	lockGlobalDNSProviderInterfaceMockUpdate                           sync.RWMutex
 	lockGlobalDNSProviderInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GlobalDNSProviderInterface = &GlobalDNSProviderInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GlobalDNSProviderList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GlobalDNSProviderList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GlobalDNSProviderInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GlobalDNSProviderList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GlobalDNSProviderList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GlobalDNSProviderInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GlobalDNSProviderInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GlobalDNSProviderInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GlobalDNSProviderList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GlobalDNSProviderInterfaceMock.ListNamespacedFunc: method is nil but GlobalDNSProviderInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGlobalDNSProviderInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGlobalDNSProviderInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGlobalDNSProviderInterface.ListNamespacedCalls())
+func (mock *GlobalDNSProviderInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGlobalDNSProviderInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGlobalDNSProviderInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GlobalDNSProviderInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_global_role_binding_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGlobalRoleBindingInterfaceMockGet                              sync.RWMutex
 	lockGlobalRoleBindingInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGlobalRoleBindingInterfaceMockList                             sync.RWMutex
+	lockGlobalRoleBindingInterfaceMockListNamespaced                   sync.RWMutex
 	lockGlobalRoleBindingInterfaceMockObjectClient                     sync.RWMutex
 	lockGlobalRoleBindingInterfaceMockUpdate                           sync.RWMutex
 	lockGlobalRoleBindingInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GlobalRoleBindingInterface = &GlobalRoleBindingInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GlobalRoleBindingList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GlobalRoleBindingList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GlobalRoleBindingInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GlobalRoleBindingList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GlobalRoleBindingList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GlobalRoleBindingInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GlobalRoleBindingInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GlobalRoleBindingInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GlobalRoleBindingList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GlobalRoleBindingInterfaceMock.ListNamespacedFunc: method is nil but GlobalRoleBindingInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGlobalRoleBindingInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGlobalRoleBindingInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGlobalRoleBindingInterface.ListNamespacedCalls())
+func (mock *GlobalRoleBindingInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGlobalRoleBindingInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGlobalRoleBindingInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GlobalRoleBindingInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_global_role_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGlobalRoleInterfaceMockGet                              sync.RWMutex
 	lockGlobalRoleInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGlobalRoleInterfaceMockList                             sync.RWMutex
+	lockGlobalRoleInterfaceMockListNamespaced                   sync.RWMutex
 	lockGlobalRoleInterfaceMockObjectClient                     sync.RWMutex
 	lockGlobalRoleInterfaceMockUpdate                           sync.RWMutex
 	lockGlobalRoleInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GlobalRoleInterface = &GlobalRoleInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GlobalRoleList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GlobalRoleList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GlobalRoleInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GlobalRoleList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GlobalRoleList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GlobalRoleInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GlobalRoleInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GlobalRoleInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GlobalRoleList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GlobalRoleInterfaceMock.ListNamespacedFunc: method is nil but GlobalRoleInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGlobalRoleInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGlobalRoleInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGlobalRoleInterface.ListNamespacedCalls())
+func (mock *GlobalRoleInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGlobalRoleInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGlobalRoleInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GlobalRoleInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_group_member_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGroupMemberInterfaceMockGet                              sync.RWMutex
 	lockGroupMemberInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGroupMemberInterfaceMockList                             sync.RWMutex
+	lockGroupMemberInterfaceMockListNamespaced                   sync.RWMutex
 	lockGroupMemberInterfaceMockObjectClient                     sync.RWMutex
 	lockGroupMemberInterfaceMockUpdate                           sync.RWMutex
 	lockGroupMemberInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GroupMemberInterface = &GroupMemberInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GroupMemberList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GroupMemberList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GroupMemberInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GroupMemberList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GroupMemberList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GroupMemberInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GroupMemberInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GroupMemberInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GroupMemberList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GroupMemberInterfaceMock.ListNamespacedFunc: method is nil but GroupMemberInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGroupMemberInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGroupMemberInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGroupMemberInterface.ListNamespacedCalls())
+func (mock *GroupMemberInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGroupMemberInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGroupMemberInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GroupMemberInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_group_mock.go

@@ -674,6 +674,7 @@ var (
 	lockGroupInterfaceMockGet                              sync.RWMutex
 	lockGroupInterfaceMockGetNamespaced                    sync.RWMutex
 	lockGroupInterfaceMockList                             sync.RWMutex
+	lockGroupInterfaceMockListNamespaced                   sync.RWMutex
 	lockGroupInterfaceMockObjectClient                     sync.RWMutex
 	lockGroupInterfaceMockUpdate                           sync.RWMutex
 	lockGroupInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.GroupInterface = &GroupInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.GroupList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.GroupList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type GroupInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.GroupList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.GroupList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type GroupInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *GroupInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *GroupInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.GroupList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("GroupInterfaceMock.ListNamespacedFunc: method is nil but GroupInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockGroupInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockGroupInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedGroupInterface.ListNamespacedCalls())
+func (mock *GroupInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockGroupInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockGroupInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *GroupInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_kontainer_driver_mock.go

@@ -674,6 +674,7 @@ var (
 	lockKontainerDriverInterfaceMockGet                              sync.RWMutex
 	lockKontainerDriverInterfaceMockGetNamespaced                    sync.RWMutex
 	lockKontainerDriverInterfaceMockList                             sync.RWMutex
+	lockKontainerDriverInterfaceMockListNamespaced                   sync.RWMutex
 	lockKontainerDriverInterfaceMockObjectClient                     sync.RWMutex
 	lockKontainerDriverInterfaceMockUpdate                           sync.RWMutex
 	lockKontainerDriverInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.KontainerDriverInterface = &KontainerDriverInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.KontainerDriverList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.KontainerDriverList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type KontainerDriverInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.KontainerDriverList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.KontainerDriverList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type KontainerDriverInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *KontainerDriverInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *KontainerDriverInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.KontainerDriverList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("KontainerDriverInterfaceMock.ListNamespacedFunc: method is nil but KontainerDriverInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockKontainerDriverInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockKontainerDriverInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedKontainerDriverInterface.ListNamespacedCalls())
+func (mock *KontainerDriverInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockKontainerDriverInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockKontainerDriverInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *KontainerDriverInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_ldap_config_mock.go

@@ -674,6 +674,7 @@ var (
 	lockLdapConfigInterfaceMockGet                              sync.RWMutex
 	lockLdapConfigInterfaceMockGetNamespaced                    sync.RWMutex
 	lockLdapConfigInterfaceMockList                             sync.RWMutex
+	lockLdapConfigInterfaceMockListNamespaced                   sync.RWMutex
 	lockLdapConfigInterfaceMockObjectClient                     sync.RWMutex
 	lockLdapConfigInterfaceMockUpdate                           sync.RWMutex
 	lockLdapConfigInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.LdapConfigInterface = &LdapConfigInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.LdapConfigList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.LdapConfigList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type LdapConfigInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.LdapConfigList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.LdapConfigList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type LdapConfigInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *LdapConfigInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *LdapConfigInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.LdapConfigList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("LdapConfigInterfaceMock.ListNamespacedFunc: method is nil but LdapConfigInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockLdapConfigInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockLdapConfigInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedLdapConfigInterface.ListNamespacedCalls())
+func (mock *LdapConfigInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockLdapConfigInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockLdapConfigInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *LdapConfigInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_listen_config_mock.go

@@ -674,6 +674,7 @@ var (
 	lockListenConfigInterfaceMockGet                              sync.RWMutex
 	lockListenConfigInterfaceMockGetNamespaced                    sync.RWMutex
 	lockListenConfigInterfaceMockList                             sync.RWMutex
+	lockListenConfigInterfaceMockListNamespaced                   sync.RWMutex
 	lockListenConfigInterfaceMockObjectClient                     sync.RWMutex
 	lockListenConfigInterfaceMockUpdate                           sync.RWMutex
 	lockListenConfigInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ListenConfigInterface = &ListenConfigInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ListenConfigList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ListenConfigList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ListenConfigInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ListenConfigList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ListenConfigList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ListenConfigInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ListenConfigInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ListenConfigInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ListenConfigList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ListenConfigInterfaceMock.ListNamespacedFunc: method is nil but ListenConfigInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockListenConfigInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockListenConfigInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedListenConfigInterface.ListNamespacedCalls())
+func (mock *ListenConfigInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockListenConfigInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockListenConfigInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ListenConfigInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_monitor_metric_mock.go

@@ -674,6 +674,7 @@ var (
 	lockMonitorMetricInterfaceMockGet                              sync.RWMutex
 	lockMonitorMetricInterfaceMockGetNamespaced                    sync.RWMutex
 	lockMonitorMetricInterfaceMockList                             sync.RWMutex
+	lockMonitorMetricInterfaceMockListNamespaced                   sync.RWMutex
 	lockMonitorMetricInterfaceMockObjectClient                     sync.RWMutex
 	lockMonitorMetricInterfaceMockUpdate                           sync.RWMutex
 	lockMonitorMetricInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.MonitorMetricInterface = &MonitorMetricInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.MonitorMetricList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.MonitorMetricList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type MonitorMetricInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.MonitorMetricList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.MonitorMetricList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type MonitorMetricInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *MonitorMetricInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *MonitorMetricInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.MonitorMetricList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("MonitorMetricInterfaceMock.ListNamespacedFunc: method is nil but MonitorMetricInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockMonitorMetricInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockMonitorMetricInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedMonitorMetricInterface.ListNamespacedCalls())
+func (mock *MonitorMetricInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockMonitorMetricInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockMonitorMetricInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *MonitorMetricInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_multi_cluster_app_mock.go

@@ -674,6 +674,7 @@ var (
 	lockMultiClusterAppInterfaceMockGet                              sync.RWMutex
 	lockMultiClusterAppInterfaceMockGetNamespaced                    sync.RWMutex
 	lockMultiClusterAppInterfaceMockList                             sync.RWMutex
+	lockMultiClusterAppInterfaceMockListNamespaced                   sync.RWMutex
 	lockMultiClusterAppInterfaceMockObjectClient                     sync.RWMutex
 	lockMultiClusterAppInterfaceMockUpdate                           sync.RWMutex
 	lockMultiClusterAppInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.MultiClusterAppInterface = &MultiClusterAppInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.MultiClusterAppList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type MultiClusterAppInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.MultiClusterAppList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type MultiClusterAppInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *MultiClusterAppInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *MultiClusterAppInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("MultiClusterAppInterfaceMock.ListNamespacedFunc: method is nil but MultiClusterAppInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockMultiClusterAppInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockMultiClusterAppInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedMultiClusterAppInterface.ListNamespacedCalls())
+func (mock *MultiClusterAppInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockMultiClusterAppInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockMultiClusterAppInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *MultiClusterAppInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_multi_cluster_app_revision_mock.go

@@ -674,6 +674,7 @@ var (
 	lockMultiClusterAppRevisionInterfaceMockGet                              sync.RWMutex
 	lockMultiClusterAppRevisionInterfaceMockGetNamespaced                    sync.RWMutex
 	lockMultiClusterAppRevisionInterfaceMockList                             sync.RWMutex
+	lockMultiClusterAppRevisionInterfaceMockListNamespaced                   sync.RWMutex
 	lockMultiClusterAppRevisionInterfaceMockObjectClient                     sync.RWMutex
 	lockMultiClusterAppRevisionInterfaceMockUpdate                           sync.RWMutex
 	lockMultiClusterAppRevisionInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.MultiClusterAppRevisionInterface = &MultiClusterAppRevisionInterfaceMoc
 //             ListFunc: func(opts v1.ListOptions) (*v3.MultiClusterAppRevisionList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppRevisionList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type MultiClusterAppRevisionInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.MultiClusterAppRevisionList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppRevisionList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type MultiClusterAppRevisionInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *MultiClusterAppRevisionInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *MultiClusterAppRevisionInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.MultiClusterAppRevisionList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("MultiClusterAppRevisionInterfaceMock.ListNamespacedFunc: method is nil but MultiClusterAppRevisionInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockMultiClusterAppRevisionInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockMultiClusterAppRevisionInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedMultiClusterAppRevisionInterface.ListNamespacedCalls())
+func (mock *MultiClusterAppRevisionInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockMultiClusterAppRevisionInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockMultiClusterAppRevisionInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *MultiClusterAppRevisionInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_node_driver_mock.go

@@ -674,6 +674,7 @@ var (
 	lockNodeDriverInterfaceMockGet                              sync.RWMutex
 	lockNodeDriverInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNodeDriverInterfaceMockList                             sync.RWMutex
+	lockNodeDriverInterfaceMockListNamespaced                   sync.RWMutex
 	lockNodeDriverInterfaceMockObjectClient                     sync.RWMutex
 	lockNodeDriverInterfaceMockUpdate                           sync.RWMutex
 	lockNodeDriverInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.NodeDriverInterface = &NodeDriverInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.NodeDriverList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.NodeDriverList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type NodeDriverInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.NodeDriverList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.NodeDriverList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type NodeDriverInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *NodeDriverInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NodeDriverInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.NodeDriverList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NodeDriverInterfaceMock.ListNamespacedFunc: method is nil but NodeDriverInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNodeDriverInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNodeDriverInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNodeDriverInterface.ListNamespacedCalls())
+func (mock *NodeDriverInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockNodeDriverInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNodeDriverInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NodeDriverInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_node_mock.go

@@ -674,6 +674,7 @@ var (
 	lockNodeInterfaceMockGet                              sync.RWMutex
 	lockNodeInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNodeInterfaceMockList                             sync.RWMutex
+	lockNodeInterfaceMockListNamespaced                   sync.RWMutex
 	lockNodeInterfaceMockObjectClient                     sync.RWMutex
 	lockNodeInterfaceMockUpdate                           sync.RWMutex
 	lockNodeInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.NodeInterface = &NodeInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.NodeList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.NodeList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type NodeInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.NodeList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.NodeList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type NodeInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *NodeInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NodeInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.NodeList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NodeInterfaceMock.ListNamespacedFunc: method is nil but NodeInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNodeInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNodeInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNodeInterface.ListNamespacedCalls())
+func (mock *NodeInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockNodeInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNodeInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NodeInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_node_pool_mock.go

@@ -674,6 +674,7 @@ var (
 	lockNodePoolInterfaceMockGet                              sync.RWMutex
 	lockNodePoolInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNodePoolInterfaceMockList                             sync.RWMutex
+	lockNodePoolInterfaceMockListNamespaced                   sync.RWMutex
 	lockNodePoolInterfaceMockObjectClient                     sync.RWMutex
 	lockNodePoolInterfaceMockUpdate                           sync.RWMutex
 	lockNodePoolInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.NodePoolInterface = &NodePoolInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.NodePoolList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.NodePoolList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type NodePoolInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.NodePoolList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.NodePoolList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type NodePoolInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *NodePoolInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NodePoolInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.NodePoolList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NodePoolInterfaceMock.ListNamespacedFunc: method is nil but NodePoolInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNodePoolInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNodePoolInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNodePoolInterface.ListNamespacedCalls())
+func (mock *NodePoolInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockNodePoolInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNodePoolInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NodePoolInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_node_template_mock.go

@@ -674,6 +674,7 @@ var (
 	lockNodeTemplateInterfaceMockGet                              sync.RWMutex
 	lockNodeTemplateInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNodeTemplateInterfaceMockList                             sync.RWMutex
+	lockNodeTemplateInterfaceMockListNamespaced                   sync.RWMutex
 	lockNodeTemplateInterfaceMockObjectClient                     sync.RWMutex
 	lockNodeTemplateInterfaceMockUpdate                           sync.RWMutex
 	lockNodeTemplateInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.NodeTemplateInterface = &NodeTemplateInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.NodeTemplateList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.NodeTemplateList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type NodeTemplateInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.NodeTemplateList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.NodeTemplateList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type NodeTemplateInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *NodeTemplateInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NodeTemplateInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.NodeTemplateList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NodeTemplateInterfaceMock.ListNamespacedFunc: method is nil but NodeTemplateInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNodeTemplateInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNodeTemplateInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNodeTemplateInterface.ListNamespacedCalls())
+func (mock *NodeTemplateInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockNodeTemplateInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNodeTemplateInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NodeTemplateInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_notifier_mock.go

@@ -674,6 +674,7 @@ var (
 	lockNotifierInterfaceMockGet                              sync.RWMutex
 	lockNotifierInterfaceMockGetNamespaced                    sync.RWMutex
 	lockNotifierInterfaceMockList                             sync.RWMutex
+	lockNotifierInterfaceMockListNamespaced                   sync.RWMutex
 	lockNotifierInterfaceMockObjectClient                     sync.RWMutex
 	lockNotifierInterfaceMockUpdate                           sync.RWMutex
 	lockNotifierInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.NotifierInterface = &NotifierInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.NotifierList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.NotifierList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type NotifierInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.NotifierList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.NotifierList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type NotifierInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *NotifierInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *NotifierInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.NotifierList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("NotifierInterfaceMock.ListNamespacedFunc: method is nil but NotifierInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockNotifierInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockNotifierInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedNotifierInterface.ListNamespacedCalls())
+func (mock *NotifierInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockNotifierInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockNotifierInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *NotifierInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_pod_security_policy_template_mock.go

@@ -674,6 +674,7 @@ var (
 	lockPodSecurityPolicyTemplateInterfaceMockGet                              sync.RWMutex
 	lockPodSecurityPolicyTemplateInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPodSecurityPolicyTemplateInterfaceMockList                             sync.RWMutex
+	lockPodSecurityPolicyTemplateInterfaceMockListNamespaced                   sync.RWMutex
 	lockPodSecurityPolicyTemplateInterfaceMockObjectClient                     sync.RWMutex
 	lockPodSecurityPolicyTemplateInterfaceMockUpdate                           sync.RWMutex
 	lockPodSecurityPolicyTemplateInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.PodSecurityPolicyTemplateInterface = &PodSecurityPolicyTemplateInterfac
 //             ListFunc: func(opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type PodSecurityPolicyTemplateInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type PodSecurityPolicyTemplateInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *PodSecurityPolicyTemplateInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PodSecurityPolicyTemplateInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PodSecurityPolicyTemplateInterfaceMock.ListNamespacedFunc: method is nil but PodSecurityPolicyTemplateInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPodSecurityPolicyTemplateInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPodSecurityPolicyTemplateInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPodSecurityPolicyTemplateInterface.ListNamespacedCalls())
+func (mock *PodSecurityPolicyTemplateInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockPodSecurityPolicyTemplateInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPodSecurityPolicyTemplateInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PodSecurityPolicyTemplateInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_pod_security_policy_template_project_binding_mock.go

@@ -674,6 +674,7 @@ var (
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockGet                              sync.RWMutex
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockList                             sync.RWMutex
+	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockListNamespaced                   sync.RWMutex
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockObjectClient                     sync.RWMutex
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockUpdate                           sync.RWMutex
 	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.PodSecurityPolicyTemplateProjectBindingInterface = &PodSecurityPolicyTe
 //             ListFunc: func(opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateProjectBindingList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateProjectBindingList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type PodSecurityPolicyTemplateProjectBindingInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateProjectBindingList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateProjectBindingList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type PodSecurityPolicyTemplateProjectBindingInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *PodSecurityPolicyTemplateProjectBindingInterfaceMock) ListCalls() []
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PodSecurityPolicyTemplateProjectBindingInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.PodSecurityPolicyTemplateProjectBindingList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PodSecurityPolicyTemplateProjectBindingInterfaceMock.ListNamespacedFunc: method is nil but PodSecurityPolicyTemplateProjectBindingInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPodSecurityPolicyTemplateProjectBindingInterface.ListNamespacedCalls())
+func (mock *PodSecurityPolicyTemplateProjectBindingInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPodSecurityPolicyTemplateProjectBindingInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PodSecurityPolicyTemplateProjectBindingInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_preference_mock.go

@@ -674,6 +674,7 @@ var (
 	lockPreferenceInterfaceMockGet                              sync.RWMutex
 	lockPreferenceInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPreferenceInterfaceMockList                             sync.RWMutex
+	lockPreferenceInterfaceMockListNamespaced                   sync.RWMutex
 	lockPreferenceInterfaceMockObjectClient                     sync.RWMutex
 	lockPreferenceInterfaceMockUpdate                           sync.RWMutex
 	lockPreferenceInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.PreferenceInterface = &PreferenceInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.PreferenceList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.PreferenceList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type PreferenceInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.PreferenceList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.PreferenceList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type PreferenceInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *PreferenceInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PreferenceInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.PreferenceList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PreferenceInterfaceMock.ListNamespacedFunc: method is nil but PreferenceInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPreferenceInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPreferenceInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPreferenceInterface.ListNamespacedCalls())
+func (mock *PreferenceInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockPreferenceInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPreferenceInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PreferenceInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_principal_mock.go

@@ -674,6 +674,7 @@ var (
 	lockPrincipalInterfaceMockGet                              sync.RWMutex
 	lockPrincipalInterfaceMockGetNamespaced                    sync.RWMutex
 	lockPrincipalInterfaceMockList                             sync.RWMutex
+	lockPrincipalInterfaceMockListNamespaced                   sync.RWMutex
 	lockPrincipalInterfaceMockObjectClient                     sync.RWMutex
 	lockPrincipalInterfaceMockUpdate                           sync.RWMutex
 	lockPrincipalInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.PrincipalInterface = &PrincipalInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.PrincipalList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.PrincipalList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type PrincipalInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.PrincipalList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.PrincipalList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type PrincipalInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *PrincipalInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *PrincipalInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.PrincipalList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("PrincipalInterfaceMock.ListNamespacedFunc: method is nil but PrincipalInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockPrincipalInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockPrincipalInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedPrincipalInterface.ListNamespacedCalls())
+func (mock *PrincipalInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockPrincipalInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockPrincipalInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *PrincipalInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_alert_group_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectAlertGroupInterfaceMockGet                              sync.RWMutex
 	lockProjectAlertGroupInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectAlertGroupInterfaceMockList                             sync.RWMutex
+	lockProjectAlertGroupInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectAlertGroupInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectAlertGroupInterfaceMockUpdate                           sync.RWMutex
 	lockProjectAlertGroupInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectAlertGroupInterface = &ProjectAlertGroupInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectAlertGroupList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertGroupList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectAlertGroupInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectAlertGroupList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertGroupList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectAlertGroupInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectAlertGroupInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectAlertGroupInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectAlertGroupList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectAlertGroupInterfaceMock.ListNamespacedFunc: method is nil but ProjectAlertGroupInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectAlertGroupInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectAlertGroupInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectAlertGroupInterface.ListNamespacedCalls())
+func (mock *ProjectAlertGroupInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectAlertGroupInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectAlertGroupInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectAlertGroupInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_alert_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectAlertInterfaceMockGet                              sync.RWMutex
 	lockProjectAlertInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectAlertInterfaceMockList                             sync.RWMutex
+	lockProjectAlertInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectAlertInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectAlertInterfaceMockUpdate                           sync.RWMutex
 	lockProjectAlertInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectAlertInterface = &ProjectAlertInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectAlertList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectAlertInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectAlertList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectAlertInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectAlertInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectAlertInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectAlertList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectAlertInterfaceMock.ListNamespacedFunc: method is nil but ProjectAlertInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectAlertInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectAlertInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectAlertInterface.ListNamespacedCalls())
+func (mock *ProjectAlertInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectAlertInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectAlertInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectAlertInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_alert_rule_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectAlertRuleInterfaceMockGet                              sync.RWMutex
 	lockProjectAlertRuleInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectAlertRuleInterfaceMockList                             sync.RWMutex
+	lockProjectAlertRuleInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectAlertRuleInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectAlertRuleInterfaceMockUpdate                           sync.RWMutex
 	lockProjectAlertRuleInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectAlertRuleInterface = &ProjectAlertRuleInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectAlertRuleList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertRuleList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectAlertRuleInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectAlertRuleList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectAlertRuleList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectAlertRuleInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectAlertRuleInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectAlertRuleInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectAlertRuleList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectAlertRuleInterfaceMock.ListNamespacedFunc: method is nil but ProjectAlertRuleInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectAlertRuleInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectAlertRuleInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectAlertRuleInterface.ListNamespacedCalls())
+func (mock *ProjectAlertRuleInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectAlertRuleInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectAlertRuleInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectAlertRuleInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_catalog_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectCatalogInterfaceMockGet                              sync.RWMutex
 	lockProjectCatalogInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectCatalogInterfaceMockList                             sync.RWMutex
+	lockProjectCatalogInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectCatalogInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectCatalogInterfaceMockUpdate                           sync.RWMutex
 	lockProjectCatalogInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectCatalogInterface = &ProjectCatalogInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectCatalogList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectCatalogList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectCatalogInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectCatalogList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectCatalogList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectCatalogInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectCatalogInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectCatalogInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectCatalogList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectCatalogInterfaceMock.ListNamespacedFunc: method is nil but ProjectCatalogInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectCatalogInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectCatalogInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectCatalogInterface.ListNamespacedCalls())
+func (mock *ProjectCatalogInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectCatalogInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectCatalogInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectCatalogInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_logging_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectLoggingInterfaceMockGet                              sync.RWMutex
 	lockProjectLoggingInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectLoggingInterfaceMockList                             sync.RWMutex
+	lockProjectLoggingInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectLoggingInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectLoggingInterfaceMockUpdate                           sync.RWMutex
 	lockProjectLoggingInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectLoggingInterface = &ProjectLoggingInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectLoggingList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectLoggingList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectLoggingInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectLoggingList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectLoggingList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectLoggingInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectLoggingInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectLoggingInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectLoggingList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectLoggingInterfaceMock.ListNamespacedFunc: method is nil but ProjectLoggingInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectLoggingInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectLoggingInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectLoggingInterface.ListNamespacedCalls())
+func (mock *ProjectLoggingInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectLoggingInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectLoggingInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectLoggingInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectInterfaceMockGet                              sync.RWMutex
 	lockProjectInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectInterfaceMockList                             sync.RWMutex
+	lockProjectInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectInterfaceMockUpdate                           sync.RWMutex
 	lockProjectInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectInterface = &ProjectInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectInterfaceMock.ListNamespacedFunc: method is nil but ProjectInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectInterface.ListNamespacedCalls())
+func (mock *ProjectInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_monitor_graph_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectMonitorGraphInterfaceMockGet                              sync.RWMutex
 	lockProjectMonitorGraphInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectMonitorGraphInterfaceMockList                             sync.RWMutex
+	lockProjectMonitorGraphInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectMonitorGraphInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectMonitorGraphInterfaceMockUpdate                           sync.RWMutex
 	lockProjectMonitorGraphInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectMonitorGraphInterface = &ProjectMonitorGraphInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectMonitorGraphList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectMonitorGraphList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectMonitorGraphInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectMonitorGraphList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectMonitorGraphList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectMonitorGraphInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectMonitorGraphInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectMonitorGraphInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectMonitorGraphList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectMonitorGraphInterfaceMock.ListNamespacedFunc: method is nil but ProjectMonitorGraphInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectMonitorGraphInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectMonitorGraphInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectMonitorGraphInterface.ListNamespacedCalls())
+func (mock *ProjectMonitorGraphInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectMonitorGraphInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectMonitorGraphInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectMonitorGraphInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {

apis/management.cattle.io/v3/fakes/zz_generated_project_network_policy_mock.go

@@ -674,6 +674,7 @@ var (
 	lockProjectNetworkPolicyInterfaceMockGet                              sync.RWMutex
 	lockProjectNetworkPolicyInterfaceMockGetNamespaced                    sync.RWMutex
 	lockProjectNetworkPolicyInterfaceMockList                             sync.RWMutex
+	lockProjectNetworkPolicyInterfaceMockListNamespaced                   sync.RWMutex
 	lockProjectNetworkPolicyInterfaceMockObjectClient                     sync.RWMutex
 	lockProjectNetworkPolicyInterfaceMockUpdate                           sync.RWMutex
 	lockProjectNetworkPolicyInterfaceMockWatch                            sync.RWMutex
@@ -737,6 +738,9 @@ var _ v3.ProjectNetworkPolicyInterface = &ProjectNetworkPolicyInterfaceMock{}
 //             ListFunc: func(opts v1.ListOptions) (*v3.ProjectNetworkPolicyList, error) {
 // 	               panic("mock out the List method")
 //             },
+//             ListNamespacedFunc: func(namespace string, opts v1.ListOptions) (*v3.ProjectNetworkPolicyList, error) {
+// 	               panic("mock out the ListNamespaced method")
+//             },
 //             ObjectClientFunc: func() *objectclient.ObjectClient {
 // 	               panic("mock out the ObjectClient method")
 //             },
@@ -801,6 +805,9 @@ type ProjectNetworkPolicyInterfaceMock struct {
 	// ListFunc mocks the List method.
 	ListFunc func(opts v1.ListOptions) (*v3.ProjectNetworkPolicyList, error)
 
+	// ListNamespacedFunc mocks the ListNamespaced method.
+	ListNamespacedFunc func(namespace string, opts v1.ListOptions) (*v3.ProjectNetworkPolicyList, error)
+
 	// ObjectClientFunc mocks the ObjectClient method.
 	ObjectClientFunc func() *objectclient.ObjectClient
 
@@ -952,6 +959,13 @@ type ProjectNetworkPolicyInterfaceMock struct {
 			// Opts is the opts argument value.
 			Opts v1.ListOptions
 		}
+		// ListNamespaced holds details about calls to the ListNamespaced method.
+		ListNamespaced []struct {
+			// Namespace is the namespace argument value.
+			Namespace string
+			// Opts is the opts argument value.
+			Opts v1.ListOptions
+		}
 		// ObjectClient holds details about calls to the ObjectClient method.
 		ObjectClient []struct {
 		}
@@ -1583,6 +1597,41 @@ func (mock *ProjectNetworkPolicyInterfaceMock) ListCalls() []struct {
 	return calls
 }
 
+// ListNamespaced calls ListNamespacedFunc.
+func (mock *ProjectNetworkPolicyInterfaceMock) ListNamespaced(namespace string, opts v1.ListOptions) (*v3.ProjectNetworkPolicyList, error) {
+	if mock.ListNamespacedFunc == nil {
+		panic("ProjectNetworkPolicyInterfaceMock.ListNamespacedFunc: method is nil but ProjectNetworkPolicyInterface.ListNamespaced was just called")
+	}
+	callInfo := struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}{
+		Namespace: namespace,
+		Opts:      opts,
+	}
+	lockProjectNetworkPolicyInterfaceMockListNamespaced.Lock()
+	mock.calls.ListNamespaced = append(mock.calls.ListNamespaced, callInfo)
+	lockProjectNetworkPolicyInterfaceMockListNamespaced.Unlock()
+	return mock.ListNamespacedFunc(namespace, opts)
+}
+
+// ListNamespacedCalls gets all the calls that were made to ListNamespaced.
+// Check the length with:
+//     len(mockedProjectNetworkPolicyInterface.ListNamespacedCalls())
+func (mock *ProjectNetworkPolicyInterfaceMock) ListNamespacedCalls() []struct {
+	Namespace string
+	Opts      v1.ListOptions
+} {
+	var calls []struct {
+		Namespace string
+		Opts      v1.ListOptions
+	}
+	lockProjectNetworkPolicyInterfaceMockListNamespaced.RLock()
+	calls = mock.calls.ListNamespaced
+	lockProjectNetworkPolicyInterfaceMockListNamespaced.RUnlock()
+	return calls
+}
+
 // ObjectClient calls ObjectClientFunc.
 func (mock *ProjectNetworkPolicyInterfaceMock) ObjectClient() *objectclient.ObjectClient {
 	if mock.ObjectClientFunc == nil {