Update generated code

apis/project.cattle.io/v3/zz_generated_deepcopy.go

@@ -69,6 +69,46 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error {
 			in.(*Link).DeepCopyInto(out.(*Link))
 			return nil
 		}, InType: reflect.TypeOf(&Link{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedBasicAuth).DeepCopyInto(out.(*NamespacedBasicAuth))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedBasicAuth{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedBasicAuthList).DeepCopyInto(out.(*NamespacedBasicAuthList))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedBasicAuthList{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedCertificate).DeepCopyInto(out.(*NamespacedCertificate))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedCertificate{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedCertificateList).DeepCopyInto(out.(*NamespacedCertificateList))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedCertificateList{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedDockerCredential).DeepCopyInto(out.(*NamespacedDockerCredential))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedDockerCredential{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedDockerCredentialList).DeepCopyInto(out.(*NamespacedDockerCredentialList))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedDockerCredentialList{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedSSHAuth).DeepCopyInto(out.(*NamespacedSSHAuth))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedSSHAuth{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedSSHAuthList).DeepCopyInto(out.(*NamespacedSSHAuthList))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedSSHAuthList{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedServiceAccountToken).DeepCopyInto(out.(*NamespacedServiceAccountToken))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedServiceAccountToken{})},
+		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
+			in.(*NamespacedServiceAccountTokenList).DeepCopyInto(out.(*NamespacedServiceAccountTokenList))
+			return nil
+		}, InType: reflect.TypeOf(&NamespacedServiceAccountTokenList{})},
 		conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error {
 			in.(*RegistryCredential).DeepCopyInto(out.(*RegistryCredential))
 			return nil
@@ -111,6 +151,7 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *BasicAuth) DeepCopyInto(out *BasicAuth) {
 	*out = *in
+	out.Namespaced = in.Namespaced
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	return
@@ -172,6 +213,7 @@ func (in *BasicAuthList) DeepCopyObject() runtime.Object {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Certificate) DeepCopyInto(out *Certificate) {
 	*out = *in
+	out.Namespaced = in.Namespaced
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	return
@@ -374,6 +416,7 @@ func (in *DeploymentParallelConfig) DeepCopy() *DeploymentParallelConfig {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *DockerCredential) DeepCopyInto(out *DockerCredential) {
 	*out = *in
+	out.Namespaced = in.Namespaced
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	if in.Registries != nil {
@@ -455,6 +498,323 @@ func (in *Link) DeepCopy() *Link {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedBasicAuth) DeepCopyInto(out *NamespacedBasicAuth) {
+	*out = *in
+	out.Namespaced = in.Namespaced
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedBasicAuth.
+func (in *NamespacedBasicAuth) DeepCopy() *NamespacedBasicAuth {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedBasicAuth)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedBasicAuth) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedBasicAuthList) DeepCopyInto(out *NamespacedBasicAuthList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]NamespacedBasicAuth, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedBasicAuthList.
+func (in *NamespacedBasicAuthList) DeepCopy() *NamespacedBasicAuthList {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedBasicAuthList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedBasicAuthList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedCertificate) DeepCopyInto(out *NamespacedCertificate) {
+	*out = *in
+	out.Namespaced = in.Namespaced
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedCertificate.
+func (in *NamespacedCertificate) DeepCopy() *NamespacedCertificate {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedCertificate)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedCertificate) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedCertificateList) DeepCopyInto(out *NamespacedCertificateList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]NamespacedCertificate, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedCertificateList.
+func (in *NamespacedCertificateList) DeepCopy() *NamespacedCertificateList {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedCertificateList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedCertificateList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedDockerCredential) DeepCopyInto(out *NamespacedDockerCredential) {
+	*out = *in
+	out.Namespaced = in.Namespaced
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	if in.Registries != nil {
+		in, out := &in.Registries, &out.Registries
+		*out = make(map[string]RegistryCredential, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedDockerCredential.
+func (in *NamespacedDockerCredential) DeepCopy() *NamespacedDockerCredential {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedDockerCredential)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedDockerCredential) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedDockerCredentialList) DeepCopyInto(out *NamespacedDockerCredentialList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]NamespacedDockerCredential, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedDockerCredentialList.
+func (in *NamespacedDockerCredentialList) DeepCopy() *NamespacedDockerCredentialList {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedDockerCredentialList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedDockerCredentialList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedSSHAuth) DeepCopyInto(out *NamespacedSSHAuth) {
+	*out = *in
+	out.Namespaced = in.Namespaced
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedSSHAuth.
+func (in *NamespacedSSHAuth) DeepCopy() *NamespacedSSHAuth {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedSSHAuth)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedSSHAuth) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedSSHAuthList) DeepCopyInto(out *NamespacedSSHAuthList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]NamespacedSSHAuth, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedSSHAuthList.
+func (in *NamespacedSSHAuthList) DeepCopy() *NamespacedSSHAuthList {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedSSHAuthList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedSSHAuthList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedServiceAccountToken) DeepCopyInto(out *NamespacedServiceAccountToken) {
+	*out = *in
+	out.Namespaced = in.Namespaced
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedServiceAccountToken.
+func (in *NamespacedServiceAccountToken) DeepCopy() *NamespacedServiceAccountToken {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedServiceAccountToken)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedServiceAccountToken) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *NamespacedServiceAccountTokenList) DeepCopyInto(out *NamespacedServiceAccountTokenList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]NamespacedServiceAccountToken, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespacedServiceAccountTokenList.
+func (in *NamespacedServiceAccountTokenList) DeepCopy() *NamespacedServiceAccountTokenList {
+	if in == nil {
+		return nil
+	}
+	out := new(NamespacedServiceAccountTokenList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *NamespacedServiceAccountTokenList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *RegistryCredential) DeepCopyInto(out *RegistryCredential) {
 	*out = *in
@@ -474,6 +834,7 @@ func (in *RegistryCredential) DeepCopy() *RegistryCredential {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *SSHAuth) DeepCopyInto(out *SSHAuth) {
 	*out = *in
+	out.Namespaced = in.Namespaced
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	return
@@ -535,6 +896,7 @@ func (in *SSHAuthList) DeepCopyObject() runtime.Object {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ServiceAccountToken) DeepCopyInto(out *ServiceAccountToken) {
 	*out = *in
+	out.Namespaced = in.Namespaced
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
 	return

apis/project.cattle.io/v3/zz_generated_k8s_client.go

@@ -19,6 +19,11 @@ type Interface interface {
 	CertificatesGetter
 	BasicAuthsGetter
 	SSHAuthsGetter
+	NamespacedServiceAccountTokensGetter
+	NamespacedDockerCredentialsGetter
+	NamespacedCertificatesGetter
+	NamespacedBasicAuthsGetter
+	NamespacedSSHAuthsGetter
 	WorkloadsGetter
 }
 
@@ -27,12 +32,17 @@ type Client struct {
 	restClient rest.Interface
 	starters   []controller.Starter
 
-	serviceAccountTokenControllers map[string]ServiceAccountTokenController
-	dockerCredentialControllers    map[string]DockerCredentialController
-	certificateControllers         map[string]CertificateController
-	basicAuthControllers           map[string]BasicAuthController
-	sshAuthControllers             map[string]SSHAuthController
-	workloadControllers            map[string]WorkloadController
+	serviceAccountTokenControllers           map[string]ServiceAccountTokenController
+	dockerCredentialControllers              map[string]DockerCredentialController
+	certificateControllers                   map[string]CertificateController
+	basicAuthControllers                     map[string]BasicAuthController
+	sshAuthControllers                       map[string]SSHAuthController
+	namespacedServiceAccountTokenControllers map[string]NamespacedServiceAccountTokenController
+	namespacedDockerCredentialControllers    map[string]NamespacedDockerCredentialController
+	namespacedCertificateControllers         map[string]NamespacedCertificateController
+	namespacedBasicAuthControllers           map[string]NamespacedBasicAuthController
+	namespacedSshAuthControllers             map[string]NamespacedSSHAuthController
+	workloadControllers                      map[string]WorkloadController
 }
 
 func NewForConfig(config rest.Config) (Interface, error) {
@@ -49,12 +59,17 @@ func NewForConfig(config rest.Config) (Interface, error) {
 	return &Client{
 		restClient: restClient,
 
-		serviceAccountTokenControllers: map[string]ServiceAccountTokenController{},
-		dockerCredentialControllers:    map[string]DockerCredentialController{},
-		certificateControllers:         map[string]CertificateController{},
-		basicAuthControllers:           map[string]BasicAuthController{},
-		sshAuthControllers:             map[string]SSHAuthController{},
-		workloadControllers:            map[string]WorkloadController{},
+		serviceAccountTokenControllers:           map[string]ServiceAccountTokenController{},
+		dockerCredentialControllers:              map[string]DockerCredentialController{},
+		certificateControllers:                   map[string]CertificateController{},
+		basicAuthControllers:                     map[string]BasicAuthController{},
+		sshAuthControllers:                       map[string]SSHAuthController{},
+		namespacedServiceAccountTokenControllers: map[string]NamespacedServiceAccountTokenController{},
+		namespacedDockerCredentialControllers:    map[string]NamespacedDockerCredentialController{},
+		namespacedCertificateControllers:         map[string]NamespacedCertificateController{},
+		namespacedBasicAuthControllers:           map[string]NamespacedBasicAuthController{},
+		namespacedSshAuthControllers:             map[string]NamespacedSSHAuthController{},
+		workloadControllers:                      map[string]WorkloadController{},
 	}, nil
 }
 
@@ -135,6 +150,71 @@ func (c *Client) SSHAuths(namespace string) SSHAuthInterface {
 	}
 }
 
+type NamespacedServiceAccountTokensGetter interface {
+	NamespacedServiceAccountTokens(namespace string) NamespacedServiceAccountTokenInterface
+}
+
+func (c *Client) NamespacedServiceAccountTokens(namespace string) NamespacedServiceAccountTokenInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &NamespacedServiceAccountTokenResource, NamespacedServiceAccountTokenGroupVersionKind, namespacedServiceAccountTokenFactory{})
+	return &namespacedServiceAccountTokenClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type NamespacedDockerCredentialsGetter interface {
+	NamespacedDockerCredentials(namespace string) NamespacedDockerCredentialInterface
+}
+
+func (c *Client) NamespacedDockerCredentials(namespace string) NamespacedDockerCredentialInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &NamespacedDockerCredentialResource, NamespacedDockerCredentialGroupVersionKind, namespacedDockerCredentialFactory{})
+	return &namespacedDockerCredentialClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type NamespacedCertificatesGetter interface {
+	NamespacedCertificates(namespace string) NamespacedCertificateInterface
+}
+
+func (c *Client) NamespacedCertificates(namespace string) NamespacedCertificateInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &NamespacedCertificateResource, NamespacedCertificateGroupVersionKind, namespacedCertificateFactory{})
+	return &namespacedCertificateClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type NamespacedBasicAuthsGetter interface {
+	NamespacedBasicAuths(namespace string) NamespacedBasicAuthInterface
+}
+
+func (c *Client) NamespacedBasicAuths(namespace string) NamespacedBasicAuthInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &NamespacedBasicAuthResource, NamespacedBasicAuthGroupVersionKind, namespacedBasicAuthFactory{})
+	return &namespacedBasicAuthClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type NamespacedSSHAuthsGetter interface {
+	NamespacedSSHAuths(namespace string) NamespacedSSHAuthInterface
+}
+
+func (c *Client) NamespacedSSHAuths(namespace string) NamespacedSSHAuthInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &NamespacedSSHAuthResource, NamespacedSSHAuthGroupVersionKind, namespacedSshAuthFactory{})
+	return &namespacedSshAuthClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
 type WorkloadsGetter interface {
 	Workloads(namespace string) WorkloadInterface
 }

apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_controller.go

@@ -0,0 +1,211 @@
+package v3
+
+import (
+	"context"
+
+	"github.com/rancher/norman/clientbase"
+	"github.com/rancher/norman/controller"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	NamespacedBasicAuthGroupVersionKind = schema.GroupVersionKind{
+		Version: Version,
+		Group:   GroupName,
+		Kind:    "NamespacedBasicAuth",
+	}
+	NamespacedBasicAuthResource = metav1.APIResource{
+		Name:         "namespacedbasicauths",
+		SingularName: "namespacedbasicauth",
+		Namespaced:   true,
+
+		Kind: NamespacedBasicAuthGroupVersionKind.Kind,
+	}
+)
+
+type NamespacedBasicAuthList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []NamespacedBasicAuth
+}
+
+type NamespacedBasicAuthHandlerFunc func(key string, obj *NamespacedBasicAuth) error
+
+type NamespacedBasicAuthLister interface {
+	List(namespace string, selector labels.Selector) (ret []*NamespacedBasicAuth, err error)
+	Get(namespace, name string) (*NamespacedBasicAuth, error)
+}
+
+type NamespacedBasicAuthController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() NamespacedBasicAuthLister
+	AddHandler(handler NamespacedBasicAuthHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type NamespacedBasicAuthInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*NamespacedBasicAuth) (*NamespacedBasicAuth, error)
+	Get(name string, opts metav1.GetOptions) (*NamespacedBasicAuth, error)
+	Update(*NamespacedBasicAuth) (*NamespacedBasicAuth, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*NamespacedBasicAuthList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() NamespacedBasicAuthController
+	AddSyncHandler(sync NamespacedBasicAuthHandlerFunc)
+	AddLifecycle(name string, lifecycle NamespacedBasicAuthLifecycle)
+}
+
+type namespacedBasicAuthLister struct {
+	controller *namespacedBasicAuthController
+}
+
+func (l *namespacedBasicAuthLister) List(namespace string, selector labels.Selector) (ret []*NamespacedBasicAuth, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*NamespacedBasicAuth))
+	})
+	return
+}
+
+func (l *namespacedBasicAuthLister) Get(namespace, name string) (*NamespacedBasicAuth, error) {
+	var key string
+	if namespace != "" {
+		key = namespace + "/" + name
+	} else {
+		key = name
+	}
+	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(schema.GroupResource{
+			Group:    NamespacedBasicAuthGroupVersionKind.Group,
+			Resource: "namespacedBasicAuth",
+		}, name)
+	}
+	return obj.(*NamespacedBasicAuth), nil
+}
+
+type namespacedBasicAuthController struct {
+	controller.GenericController
+}
+
+func (c *namespacedBasicAuthController) Lister() NamespacedBasicAuthLister {
+	return &namespacedBasicAuthLister{
+		controller: c,
+	}
+}
+
+func (c *namespacedBasicAuthController) AddHandler(handler NamespacedBasicAuthHandlerFunc) {
+	c.GenericController.AddHandler(func(key string) error {
+		obj, exists, err := c.Informer().GetStore().GetByKey(key)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return handler(key, nil)
+		}
+		return handler(key, obj.(*NamespacedBasicAuth))
+	})
+}
+
+type namespacedBasicAuthFactory struct {
+}
+
+func (c namespacedBasicAuthFactory) Object() runtime.Object {
+	return &NamespacedBasicAuth{}
+}
+
+func (c namespacedBasicAuthFactory) List() runtime.Object {
+	return &NamespacedBasicAuthList{}
+}
+
+func (s *namespacedBasicAuthClient) Controller() NamespacedBasicAuthController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.namespacedBasicAuthControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(NamespacedBasicAuthGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &namespacedBasicAuthController{
+		GenericController: genericController,
+	}
+
+	s.client.namespacedBasicAuthControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type namespacedBasicAuthClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   NamespacedBasicAuthController
+}
+
+func (s *namespacedBasicAuthClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *namespacedBasicAuthClient) Create(o *NamespacedBasicAuth) (*NamespacedBasicAuth, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*NamespacedBasicAuth), err
+}
+
+func (s *namespacedBasicAuthClient) Get(name string, opts metav1.GetOptions) (*NamespacedBasicAuth, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*NamespacedBasicAuth), err
+}
+
+func (s *namespacedBasicAuthClient) Update(o *NamespacedBasicAuth) (*NamespacedBasicAuth, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*NamespacedBasicAuth), err
+}
+
+func (s *namespacedBasicAuthClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *namespacedBasicAuthClient) List(opts metav1.ListOptions) (*NamespacedBasicAuthList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*NamespacedBasicAuthList), err
+}
+
+func (s *namespacedBasicAuthClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (s *namespacedBasicAuthClient) Patch(o *NamespacedBasicAuth, data []byte, subresources ...string) (*NamespacedBasicAuth, error) {
+	obj, err := s.objectClient.Patch(o.Name, o, data, subresources...)
+	return obj.(*NamespacedBasicAuth), err
+}
+
+func (s *namespacedBasicAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}
+
+func (s *namespacedBasicAuthClient) AddSyncHandler(sync NamespacedBasicAuthHandlerFunc) {
+	s.Controller().AddHandler(sync)
+}
+
+func (s *namespacedBasicAuthClient) AddLifecycle(name string, lifecycle NamespacedBasicAuthLifecycle) {
+	sync := NewNamespacedBasicAuthLifecycleAdapter(name, s, lifecycle)
+	s.AddSyncHandler(sync)
+}

apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_lifecycle_adapter.go

@@ -0,0 +1,51 @@
+package v3
+
+import (
+	"github.com/rancher/norman/lifecycle"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type NamespacedBasicAuthLifecycle interface {
+	Create(obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error)
+	Remove(obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error)
+	Updated(obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error)
+}
+
+type namespacedBasicAuthLifecycleAdapter struct {
+	lifecycle NamespacedBasicAuthLifecycle
+}
+
+func (w *namespacedBasicAuthLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*NamespacedBasicAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedBasicAuthLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*NamespacedBasicAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedBasicAuthLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*NamespacedBasicAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func NewNamespacedBasicAuthLifecycleAdapter(name string, client NamespacedBasicAuthInterface, l NamespacedBasicAuthLifecycle) NamespacedBasicAuthHandlerFunc {
+	adapter := &namespacedBasicAuthLifecycleAdapter{lifecycle: l}
+	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
+	return func(key string, obj *NamespacedBasicAuth) error {
+		if obj == nil {
+			return syncFn(key, nil)
+		}
+		return syncFn(key, obj)
+	}
+}

apis/project.cattle.io/v3/zz_generated_namespaced_certificate_controller.go

@@ -0,0 +1,211 @@
+package v3
+
+import (
+	"context"
+
+	"github.com/rancher/norman/clientbase"
+	"github.com/rancher/norman/controller"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	NamespacedCertificateGroupVersionKind = schema.GroupVersionKind{
+		Version: Version,
+		Group:   GroupName,
+		Kind:    "NamespacedCertificate",
+	}
+	NamespacedCertificateResource = metav1.APIResource{
+		Name:         "namespacedcertificates",
+		SingularName: "namespacedcertificate",
+		Namespaced:   true,
+
+		Kind: NamespacedCertificateGroupVersionKind.Kind,
+	}
+)
+
+type NamespacedCertificateList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []NamespacedCertificate
+}
+
+type NamespacedCertificateHandlerFunc func(key string, obj *NamespacedCertificate) error
+
+type NamespacedCertificateLister interface {
+	List(namespace string, selector labels.Selector) (ret []*NamespacedCertificate, err error)
+	Get(namespace, name string) (*NamespacedCertificate, error)
+}
+
+type NamespacedCertificateController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() NamespacedCertificateLister
+	AddHandler(handler NamespacedCertificateHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type NamespacedCertificateInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*NamespacedCertificate) (*NamespacedCertificate, error)
+	Get(name string, opts metav1.GetOptions) (*NamespacedCertificate, error)
+	Update(*NamespacedCertificate) (*NamespacedCertificate, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*NamespacedCertificateList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() NamespacedCertificateController
+	AddSyncHandler(sync NamespacedCertificateHandlerFunc)
+	AddLifecycle(name string, lifecycle NamespacedCertificateLifecycle)
+}
+
+type namespacedCertificateLister struct {
+	controller *namespacedCertificateController
+}
+
+func (l *namespacedCertificateLister) List(namespace string, selector labels.Selector) (ret []*NamespacedCertificate, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*NamespacedCertificate))
+	})
+	return
+}
+
+func (l *namespacedCertificateLister) Get(namespace, name string) (*NamespacedCertificate, error) {
+	var key string
+	if namespace != "" {
+		key = namespace + "/" + name
+	} else {
+		key = name
+	}
+	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(schema.GroupResource{
+			Group:    NamespacedCertificateGroupVersionKind.Group,
+			Resource: "namespacedCertificate",
+		}, name)
+	}
+	return obj.(*NamespacedCertificate), nil
+}
+
+type namespacedCertificateController struct {
+	controller.GenericController
+}
+
+func (c *namespacedCertificateController) Lister() NamespacedCertificateLister {
+	return &namespacedCertificateLister{
+		controller: c,
+	}
+}
+
+func (c *namespacedCertificateController) AddHandler(handler NamespacedCertificateHandlerFunc) {
+	c.GenericController.AddHandler(func(key string) error {
+		obj, exists, err := c.Informer().GetStore().GetByKey(key)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return handler(key, nil)
+		}
+		return handler(key, obj.(*NamespacedCertificate))
+	})
+}
+
+type namespacedCertificateFactory struct {
+}
+
+func (c namespacedCertificateFactory) Object() runtime.Object {
+	return &NamespacedCertificate{}
+}
+
+func (c namespacedCertificateFactory) List() runtime.Object {
+	return &NamespacedCertificateList{}
+}
+
+func (s *namespacedCertificateClient) Controller() NamespacedCertificateController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.namespacedCertificateControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(NamespacedCertificateGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &namespacedCertificateController{
+		GenericController: genericController,
+	}
+
+	s.client.namespacedCertificateControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type namespacedCertificateClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   NamespacedCertificateController
+}
+
+func (s *namespacedCertificateClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *namespacedCertificateClient) Create(o *NamespacedCertificate) (*NamespacedCertificate, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*NamespacedCertificate), err
+}
+
+func (s *namespacedCertificateClient) Get(name string, opts metav1.GetOptions) (*NamespacedCertificate, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*NamespacedCertificate), err
+}
+
+func (s *namespacedCertificateClient) Update(o *NamespacedCertificate) (*NamespacedCertificate, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*NamespacedCertificate), err
+}
+
+func (s *namespacedCertificateClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *namespacedCertificateClient) List(opts metav1.ListOptions) (*NamespacedCertificateList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*NamespacedCertificateList), err
+}
+
+func (s *namespacedCertificateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (s *namespacedCertificateClient) Patch(o *NamespacedCertificate, data []byte, subresources ...string) (*NamespacedCertificate, error) {
+	obj, err := s.objectClient.Patch(o.Name, o, data, subresources...)
+	return obj.(*NamespacedCertificate), err
+}
+
+func (s *namespacedCertificateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}
+
+func (s *namespacedCertificateClient) AddSyncHandler(sync NamespacedCertificateHandlerFunc) {
+	s.Controller().AddHandler(sync)
+}
+
+func (s *namespacedCertificateClient) AddLifecycle(name string, lifecycle NamespacedCertificateLifecycle) {
+	sync := NewNamespacedCertificateLifecycleAdapter(name, s, lifecycle)
+	s.AddSyncHandler(sync)
+}

apis/project.cattle.io/v3/zz_generated_namespaced_certificate_lifecycle_adapter.go

@@ -0,0 +1,51 @@
+package v3
+
+import (
+	"github.com/rancher/norman/lifecycle"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type NamespacedCertificateLifecycle interface {
+	Create(obj *NamespacedCertificate) (*NamespacedCertificate, error)
+	Remove(obj *NamespacedCertificate) (*NamespacedCertificate, error)
+	Updated(obj *NamespacedCertificate) (*NamespacedCertificate, error)
+}
+
+type namespacedCertificateLifecycleAdapter struct {
+	lifecycle NamespacedCertificateLifecycle
+}
+
+func (w *namespacedCertificateLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*NamespacedCertificate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedCertificateLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*NamespacedCertificate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedCertificateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*NamespacedCertificate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func NewNamespacedCertificateLifecycleAdapter(name string, client NamespacedCertificateInterface, l NamespacedCertificateLifecycle) NamespacedCertificateHandlerFunc {
+	adapter := &namespacedCertificateLifecycleAdapter{lifecycle: l}
+	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
+	return func(key string, obj *NamespacedCertificate) error {
+		if obj == nil {
+			return syncFn(key, nil)
+		}
+		return syncFn(key, obj)
+	}
+}

apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_controller.go

@@ -0,0 +1,211 @@
+package v3
+
+import (
+	"context"
+
+	"github.com/rancher/norman/clientbase"
+	"github.com/rancher/norman/controller"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	NamespacedDockerCredentialGroupVersionKind = schema.GroupVersionKind{
+		Version: Version,
+		Group:   GroupName,
+		Kind:    "NamespacedDockerCredential",
+	}
+	NamespacedDockerCredentialResource = metav1.APIResource{
+		Name:         "namespaceddockercredentials",
+		SingularName: "namespaceddockercredential",
+		Namespaced:   true,
+
+		Kind: NamespacedDockerCredentialGroupVersionKind.Kind,
+	}
+)
+
+type NamespacedDockerCredentialList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []NamespacedDockerCredential
+}
+
+type NamespacedDockerCredentialHandlerFunc func(key string, obj *NamespacedDockerCredential) error
+
+type NamespacedDockerCredentialLister interface {
+	List(namespace string, selector labels.Selector) (ret []*NamespacedDockerCredential, err error)
+	Get(namespace, name string) (*NamespacedDockerCredential, error)
+}
+
+type NamespacedDockerCredentialController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() NamespacedDockerCredentialLister
+	AddHandler(handler NamespacedDockerCredentialHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type NamespacedDockerCredentialInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*NamespacedDockerCredential) (*NamespacedDockerCredential, error)
+	Get(name string, opts metav1.GetOptions) (*NamespacedDockerCredential, error)
+	Update(*NamespacedDockerCredential) (*NamespacedDockerCredential, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*NamespacedDockerCredentialList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() NamespacedDockerCredentialController
+	AddSyncHandler(sync NamespacedDockerCredentialHandlerFunc)
+	AddLifecycle(name string, lifecycle NamespacedDockerCredentialLifecycle)
+}
+
+type namespacedDockerCredentialLister struct {
+	controller *namespacedDockerCredentialController
+}
+
+func (l *namespacedDockerCredentialLister) List(namespace string, selector labels.Selector) (ret []*NamespacedDockerCredential, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*NamespacedDockerCredential))
+	})
+	return
+}
+
+func (l *namespacedDockerCredentialLister) Get(namespace, name string) (*NamespacedDockerCredential, error) {
+	var key string
+	if namespace != "" {
+		key = namespace + "/" + name
+	} else {
+		key = name
+	}
+	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(schema.GroupResource{
+			Group:    NamespacedDockerCredentialGroupVersionKind.Group,
+			Resource: "namespacedDockerCredential",
+		}, name)
+	}
+	return obj.(*NamespacedDockerCredential), nil
+}
+
+type namespacedDockerCredentialController struct {
+	controller.GenericController
+}
+
+func (c *namespacedDockerCredentialController) Lister() NamespacedDockerCredentialLister {
+	return &namespacedDockerCredentialLister{
+		controller: c,
+	}
+}
+
+func (c *namespacedDockerCredentialController) AddHandler(handler NamespacedDockerCredentialHandlerFunc) {
+	c.GenericController.AddHandler(func(key string) error {
+		obj, exists, err := c.Informer().GetStore().GetByKey(key)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return handler(key, nil)
+		}
+		return handler(key, obj.(*NamespacedDockerCredential))
+	})
+}
+
+type namespacedDockerCredentialFactory struct {
+}
+
+func (c namespacedDockerCredentialFactory) Object() runtime.Object {
+	return &NamespacedDockerCredential{}
+}
+
+func (c namespacedDockerCredentialFactory) List() runtime.Object {
+	return &NamespacedDockerCredentialList{}
+}
+
+func (s *namespacedDockerCredentialClient) Controller() NamespacedDockerCredentialController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.namespacedDockerCredentialControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(NamespacedDockerCredentialGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &namespacedDockerCredentialController{
+		GenericController: genericController,
+	}
+
+	s.client.namespacedDockerCredentialControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type namespacedDockerCredentialClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   NamespacedDockerCredentialController
+}
+
+func (s *namespacedDockerCredentialClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *namespacedDockerCredentialClient) Create(o *NamespacedDockerCredential) (*NamespacedDockerCredential, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*NamespacedDockerCredential), err
+}
+
+func (s *namespacedDockerCredentialClient) Get(name string, opts metav1.GetOptions) (*NamespacedDockerCredential, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*NamespacedDockerCredential), err
+}
+
+func (s *namespacedDockerCredentialClient) Update(o *NamespacedDockerCredential) (*NamespacedDockerCredential, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*NamespacedDockerCredential), err
+}
+
+func (s *namespacedDockerCredentialClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *namespacedDockerCredentialClient) List(opts metav1.ListOptions) (*NamespacedDockerCredentialList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*NamespacedDockerCredentialList), err
+}
+
+func (s *namespacedDockerCredentialClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (s *namespacedDockerCredentialClient) Patch(o *NamespacedDockerCredential, data []byte, subresources ...string) (*NamespacedDockerCredential, error) {
+	obj, err := s.objectClient.Patch(o.Name, o, data, subresources...)
+	return obj.(*NamespacedDockerCredential), err
+}
+
+func (s *namespacedDockerCredentialClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}
+
+func (s *namespacedDockerCredentialClient) AddSyncHandler(sync NamespacedDockerCredentialHandlerFunc) {
+	s.Controller().AddHandler(sync)
+}
+
+func (s *namespacedDockerCredentialClient) AddLifecycle(name string, lifecycle NamespacedDockerCredentialLifecycle) {
+	sync := NewNamespacedDockerCredentialLifecycleAdapter(name, s, lifecycle)
+	s.AddSyncHandler(sync)
+}

apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_lifecycle_adapter.go

@@ -0,0 +1,51 @@
+package v3
+
+import (
+	"github.com/rancher/norman/lifecycle"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type NamespacedDockerCredentialLifecycle interface {
+	Create(obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error)
+	Remove(obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error)
+	Updated(obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error)
+}
+
+type namespacedDockerCredentialLifecycleAdapter struct {
+	lifecycle NamespacedDockerCredentialLifecycle
+}
+
+func (w *namespacedDockerCredentialLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*NamespacedDockerCredential))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedDockerCredentialLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*NamespacedDockerCredential))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedDockerCredentialLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*NamespacedDockerCredential))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func NewNamespacedDockerCredentialLifecycleAdapter(name string, client NamespacedDockerCredentialInterface, l NamespacedDockerCredentialLifecycle) NamespacedDockerCredentialHandlerFunc {
+	adapter := &namespacedDockerCredentialLifecycleAdapter{lifecycle: l}
+	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
+	return func(key string, obj *NamespacedDockerCredential) error {
+		if obj == nil {
+			return syncFn(key, nil)
+		}
+		return syncFn(key, obj)
+	}
+}

apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_controller.go

@@ -0,0 +1,211 @@
+package v3
+
+import (
+	"context"
+
+	"github.com/rancher/norman/clientbase"
+	"github.com/rancher/norman/controller"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	NamespacedServiceAccountTokenGroupVersionKind = schema.GroupVersionKind{
+		Version: Version,
+		Group:   GroupName,
+		Kind:    "NamespacedServiceAccountToken",
+	}
+	NamespacedServiceAccountTokenResource = metav1.APIResource{
+		Name:         "namespacedserviceaccounttokens",
+		SingularName: "namespacedserviceaccounttoken",
+		Namespaced:   true,
+
+		Kind: NamespacedServiceAccountTokenGroupVersionKind.Kind,
+	}
+)
+
+type NamespacedServiceAccountTokenList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []NamespacedServiceAccountToken
+}
+
+type NamespacedServiceAccountTokenHandlerFunc func(key string, obj *NamespacedServiceAccountToken) error
+
+type NamespacedServiceAccountTokenLister interface {
+	List(namespace string, selector labels.Selector) (ret []*NamespacedServiceAccountToken, err error)
+	Get(namespace, name string) (*NamespacedServiceAccountToken, error)
+}
+
+type NamespacedServiceAccountTokenController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() NamespacedServiceAccountTokenLister
+	AddHandler(handler NamespacedServiceAccountTokenHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type NamespacedServiceAccountTokenInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error)
+	Get(name string, opts metav1.GetOptions) (*NamespacedServiceAccountToken, error)
+	Update(*NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*NamespacedServiceAccountTokenList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() NamespacedServiceAccountTokenController
+	AddSyncHandler(sync NamespacedServiceAccountTokenHandlerFunc)
+	AddLifecycle(name string, lifecycle NamespacedServiceAccountTokenLifecycle)
+}
+
+type namespacedServiceAccountTokenLister struct {
+	controller *namespacedServiceAccountTokenController
+}
+
+func (l *namespacedServiceAccountTokenLister) List(namespace string, selector labels.Selector) (ret []*NamespacedServiceAccountToken, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*NamespacedServiceAccountToken))
+	})
+	return
+}
+
+func (l *namespacedServiceAccountTokenLister) Get(namespace, name string) (*NamespacedServiceAccountToken, error) {
+	var key string
+	if namespace != "" {
+		key = namespace + "/" + name
+	} else {
+		key = name
+	}
+	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(schema.GroupResource{
+			Group:    NamespacedServiceAccountTokenGroupVersionKind.Group,
+			Resource: "namespacedServiceAccountToken",
+		}, name)
+	}
+	return obj.(*NamespacedServiceAccountToken), nil
+}
+
+type namespacedServiceAccountTokenController struct {
+	controller.GenericController
+}
+
+func (c *namespacedServiceAccountTokenController) Lister() NamespacedServiceAccountTokenLister {
+	return &namespacedServiceAccountTokenLister{
+		controller: c,
+	}
+}
+
+func (c *namespacedServiceAccountTokenController) AddHandler(handler NamespacedServiceAccountTokenHandlerFunc) {
+	c.GenericController.AddHandler(func(key string) error {
+		obj, exists, err := c.Informer().GetStore().GetByKey(key)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return handler(key, nil)
+		}
+		return handler(key, obj.(*NamespacedServiceAccountToken))
+	})
+}
+
+type namespacedServiceAccountTokenFactory struct {
+}
+
+func (c namespacedServiceAccountTokenFactory) Object() runtime.Object {
+	return &NamespacedServiceAccountToken{}
+}
+
+func (c namespacedServiceAccountTokenFactory) List() runtime.Object {
+	return &NamespacedServiceAccountTokenList{}
+}
+
+func (s *namespacedServiceAccountTokenClient) Controller() NamespacedServiceAccountTokenController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.namespacedServiceAccountTokenControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(NamespacedServiceAccountTokenGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &namespacedServiceAccountTokenController{
+		GenericController: genericController,
+	}
+
+	s.client.namespacedServiceAccountTokenControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type namespacedServiceAccountTokenClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   NamespacedServiceAccountTokenController
+}
+
+func (s *namespacedServiceAccountTokenClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *namespacedServiceAccountTokenClient) Create(o *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*NamespacedServiceAccountToken), err
+}
+
+func (s *namespacedServiceAccountTokenClient) Get(name string, opts metav1.GetOptions) (*NamespacedServiceAccountToken, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*NamespacedServiceAccountToken), err
+}
+
+func (s *namespacedServiceAccountTokenClient) Update(o *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*NamespacedServiceAccountToken), err
+}
+
+func (s *namespacedServiceAccountTokenClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *namespacedServiceAccountTokenClient) List(opts metav1.ListOptions) (*NamespacedServiceAccountTokenList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*NamespacedServiceAccountTokenList), err
+}
+
+func (s *namespacedServiceAccountTokenClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (s *namespacedServiceAccountTokenClient) Patch(o *NamespacedServiceAccountToken, data []byte, subresources ...string) (*NamespacedServiceAccountToken, error) {
+	obj, err := s.objectClient.Patch(o.Name, o, data, subresources...)
+	return obj.(*NamespacedServiceAccountToken), err
+}
+
+func (s *namespacedServiceAccountTokenClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}
+
+func (s *namespacedServiceAccountTokenClient) AddSyncHandler(sync NamespacedServiceAccountTokenHandlerFunc) {
+	s.Controller().AddHandler(sync)
+}
+
+func (s *namespacedServiceAccountTokenClient) AddLifecycle(name string, lifecycle NamespacedServiceAccountTokenLifecycle) {
+	sync := NewNamespacedServiceAccountTokenLifecycleAdapter(name, s, lifecycle)
+	s.AddSyncHandler(sync)
+}

apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_lifecycle_adapter.go

@@ -0,0 +1,51 @@
+package v3
+
+import (
+	"github.com/rancher/norman/lifecycle"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type NamespacedServiceAccountTokenLifecycle interface {
+	Create(obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error)
+	Remove(obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error)
+	Updated(obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error)
+}
+
+type namespacedServiceAccountTokenLifecycleAdapter struct {
+	lifecycle NamespacedServiceAccountTokenLifecycle
+}
+
+func (w *namespacedServiceAccountTokenLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*NamespacedServiceAccountToken))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedServiceAccountTokenLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*NamespacedServiceAccountToken))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedServiceAccountTokenLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*NamespacedServiceAccountToken))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func NewNamespacedServiceAccountTokenLifecycleAdapter(name string, client NamespacedServiceAccountTokenInterface, l NamespacedServiceAccountTokenLifecycle) NamespacedServiceAccountTokenHandlerFunc {
+	adapter := &namespacedServiceAccountTokenLifecycleAdapter{lifecycle: l}
+	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
+	return func(key string, obj *NamespacedServiceAccountToken) error {
+		if obj == nil {
+			return syncFn(key, nil)
+		}
+		return syncFn(key, obj)
+	}
+}

apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_controller.go

@@ -0,0 +1,211 @@
+package v3
+
+import (
+	"context"
+
+	"github.com/rancher/norman/clientbase"
+	"github.com/rancher/norman/controller"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/tools/cache"
+)
+
+var (
+	NamespacedSSHAuthGroupVersionKind = schema.GroupVersionKind{
+		Version: Version,
+		Group:   GroupName,
+		Kind:    "NamespacedSSHAuth",
+	}
+	NamespacedSSHAuthResource = metav1.APIResource{
+		Name:         "namespacedsshauths",
+		SingularName: "namespacedsshauth",
+		Namespaced:   true,
+
+		Kind: NamespacedSSHAuthGroupVersionKind.Kind,
+	}
+)
+
+type NamespacedSSHAuthList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []NamespacedSSHAuth
+}
+
+type NamespacedSSHAuthHandlerFunc func(key string, obj *NamespacedSSHAuth) error
+
+type NamespacedSSHAuthLister interface {
+	List(namespace string, selector labels.Selector) (ret []*NamespacedSSHAuth, err error)
+	Get(namespace, name string) (*NamespacedSSHAuth, error)
+}
+
+type NamespacedSSHAuthController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() NamespacedSSHAuthLister
+	AddHandler(handler NamespacedSSHAuthHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type NamespacedSSHAuthInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*NamespacedSSHAuth) (*NamespacedSSHAuth, error)
+	Get(name string, opts metav1.GetOptions) (*NamespacedSSHAuth, error)
+	Update(*NamespacedSSHAuth) (*NamespacedSSHAuth, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*NamespacedSSHAuthList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() NamespacedSSHAuthController
+	AddSyncHandler(sync NamespacedSSHAuthHandlerFunc)
+	AddLifecycle(name string, lifecycle NamespacedSSHAuthLifecycle)
+}
+
+type namespacedSshAuthLister struct {
+	controller *namespacedSshAuthController
+}
+
+func (l *namespacedSshAuthLister) List(namespace string, selector labels.Selector) (ret []*NamespacedSSHAuth, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*NamespacedSSHAuth))
+	})
+	return
+}
+
+func (l *namespacedSshAuthLister) Get(namespace, name string) (*NamespacedSSHAuth, error) {
+	var key string
+	if namespace != "" {
+		key = namespace + "/" + name
+	} else {
+		key = name
+	}
+	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(schema.GroupResource{
+			Group:    NamespacedSSHAuthGroupVersionKind.Group,
+			Resource: "namespacedSshAuth",
+		}, name)
+	}
+	return obj.(*NamespacedSSHAuth), nil
+}
+
+type namespacedSshAuthController struct {
+	controller.GenericController
+}
+
+func (c *namespacedSshAuthController) Lister() NamespacedSSHAuthLister {
+	return &namespacedSshAuthLister{
+		controller: c,
+	}
+}
+
+func (c *namespacedSshAuthController) AddHandler(handler NamespacedSSHAuthHandlerFunc) {
+	c.GenericController.AddHandler(func(key string) error {
+		obj, exists, err := c.Informer().GetStore().GetByKey(key)
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return handler(key, nil)
+		}
+		return handler(key, obj.(*NamespacedSSHAuth))
+	})
+}
+
+type namespacedSshAuthFactory struct {
+}
+
+func (c namespacedSshAuthFactory) Object() runtime.Object {
+	return &NamespacedSSHAuth{}
+}
+
+func (c namespacedSshAuthFactory) List() runtime.Object {
+	return &NamespacedSSHAuthList{}
+}
+
+func (s *namespacedSshAuthClient) Controller() NamespacedSSHAuthController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.namespacedSshAuthControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(NamespacedSSHAuthGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &namespacedSshAuthController{
+		GenericController: genericController,
+	}
+
+	s.client.namespacedSshAuthControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type namespacedSshAuthClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   NamespacedSSHAuthController
+}
+
+func (s *namespacedSshAuthClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *namespacedSshAuthClient) Create(o *NamespacedSSHAuth) (*NamespacedSSHAuth, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*NamespacedSSHAuth), err
+}
+
+func (s *namespacedSshAuthClient) Get(name string, opts metav1.GetOptions) (*NamespacedSSHAuth, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*NamespacedSSHAuth), err
+}
+
+func (s *namespacedSshAuthClient) Update(o *NamespacedSSHAuth) (*NamespacedSSHAuth, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*NamespacedSSHAuth), err
+}
+
+func (s *namespacedSshAuthClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *namespacedSshAuthClient) List(opts metav1.ListOptions) (*NamespacedSSHAuthList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*NamespacedSSHAuthList), err
+}
+
+func (s *namespacedSshAuthClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (s *namespacedSshAuthClient) Patch(o *NamespacedSSHAuth, data []byte, subresources ...string) (*NamespacedSSHAuth, error) {
+	obj, err := s.objectClient.Patch(o.Name, o, data, subresources...)
+	return obj.(*NamespacedSSHAuth), err
+}
+
+func (s *namespacedSshAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}
+
+func (s *namespacedSshAuthClient) AddSyncHandler(sync NamespacedSSHAuthHandlerFunc) {
+	s.Controller().AddHandler(sync)
+}
+
+func (s *namespacedSshAuthClient) AddLifecycle(name string, lifecycle NamespacedSSHAuthLifecycle) {
+	sync := NewNamespacedSSHAuthLifecycleAdapter(name, s, lifecycle)
+	s.AddSyncHandler(sync)
+}

apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_lifecycle_adapter.go

@@ -0,0 +1,51 @@
+package v3
+
+import (
+	"github.com/rancher/norman/lifecycle"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type NamespacedSSHAuthLifecycle interface {
+	Create(obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error)
+	Remove(obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error)
+	Updated(obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error)
+}
+
+type namespacedSshAuthLifecycleAdapter struct {
+	lifecycle NamespacedSSHAuthLifecycle
+}
+
+func (w *namespacedSshAuthLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*NamespacedSSHAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedSshAuthLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*NamespacedSSHAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func (w *namespacedSshAuthLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*NamespacedSSHAuth))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
+}
+
+func NewNamespacedSSHAuthLifecycleAdapter(name string, client NamespacedSSHAuthInterface, l NamespacedSSHAuthLifecycle) NamespacedSSHAuthHandlerFunc {
+	adapter := &namespacedSshAuthLifecycleAdapter{lifecycle: l}
+	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
+	return func(key string, obj *NamespacedSSHAuth) error {
+		if obj == nil {
+			return syncFn(key, nil)
+		}
+		return syncFn(key, obj)
+	}
+}

apis/project.cattle.io/v3/zz_generated_scheme.go

@@ -43,6 +43,16 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 		&BasicAuthList{},
 		&SSHAuth{},
 		&SSHAuthList{},
+		&NamespacedServiceAccountToken{},
+		&NamespacedServiceAccountTokenList{},
+		&NamespacedDockerCredential{},
+		&NamespacedDockerCredentialList{},
+		&NamespacedCertificate{},
+		&NamespacedCertificateList{},
+		&NamespacedBasicAuth{},
+		&NamespacedBasicAuthList{},
+		&NamespacedSSHAuth{},
+		&NamespacedSSHAuthList{},
 		&Workload{},
 		&WorkloadList{},
 	)