vendor bump

vendor/github.com/rancher/norman/lifecycle/object.go

@@ -9,13 +9,13 @@ import (
 )
 
 var (
-	initialized = "io.cattle.lifecycle.initialized"
+	created = "io.cattle.lifecycle.create"
 )
 
 type ObjectLifecycle interface {
-	Initialize(obj runtime.Object) error
-	Finalize(obj runtime.Object) error
-	Updated(obj runtime.Object) error
+	Create(obj runtime.Object) (runtime.Object, error)
+	Finalize(obj runtime.Object) (runtime.Object, error)
+	Updated(obj runtime.Object) (runtime.Object, error)
 }
 
 type objectLifecycleAdapter struct {
@@ -47,11 +47,18 @@ func (o *objectLifecycleAdapter) sync(key string, obj runtime.Object) error {
 		return err
 	}
 
-	if cont, err := o.initialize(metadata, obj); err != nil || !cont {
+	if cont, err := o.create(metadata, obj); err != nil || !cont {
 		return err
 	}
 
-	return o.lifecycle.Updated(obj.DeepCopyObject())
+	if newObj, err := o.lifecycle.Updated(obj); err != nil {
+		return err
+	} else if newObj != nil {
+		_, err = o.objectClient.Update(metadata.GetName(), newObj)
+		return err
+	}
+
+	return nil
 }
 
 func (o *objectLifecycleAdapter) finalize(metadata metav1.Object, obj runtime.Object) (bool, error) {
@@ -79,20 +86,23 @@ func (o *objectLifecycleAdapter) finalize(metadata metav1.Object, obj runtime.Ob
 	}
 	metadata.SetFinalizers(finalizers)
 
-	if err := o.lifecycle.Finalize(obj); err != nil {
+	if newObj, err := o.lifecycle.Finalize(obj); err != nil {
 		return false, err
+	} else if newObj != nil {
+		_, err = o.objectClient.Update(metadata.GetName(), newObj)
+	} else {
+		_, err = o.objectClient.Update(metadata.GetName(), obj)
 	}
 
-	_, err = o.objectClient.Update(metadata.GetName(), obj)
 	return false, err
 }
 
-func (o *objectLifecycleAdapter) initializeKey() string {
-	return initialized + "." + o.name
+func (o *objectLifecycleAdapter) createKey() string {
+	return created + "." + o.name
 }
 
-func (o *objectLifecycleAdapter) initialize(metadata metav1.Object, obj runtime.Object) (bool, error) {
-	initialized := o.initializeKey()
+func (o *objectLifecycleAdapter) create(metadata metav1.Object, obj runtime.Object) (bool, error) {
+	initialized := o.createKey()
 
 	if metadata.GetLabels()[initialized] == "true" {
 		return true, nil
@@ -110,7 +120,10 @@ func (o *objectLifecycleAdapter) initialize(metadata metav1.Object, obj runtime.
 
 	metadata.SetFinalizers(append(metadata.GetFinalizers(), o.name))
 	metadata.GetLabels()[initialized] = "true"
-	if err := o.lifecycle.Initialize(obj); err != nil {
+	if newObj, err := o.lifecycle.Create(obj); err != nil {
+		return false, err
+	} else if newObj != nil {
+		_, err = o.objectClient.Update(metadata.GetName(), newObj)
 		return false, err
 	}
 

vendor/github.com/rancher/norman/types/definition/definition.go

@@ -32,7 +32,11 @@ func SubType(fieldType string) string {
 }
 
 func GetType(data map[string]interface{}) string {
-	parts := strings.Split(GetFullType(data), "/")
+	return GetShortTypeFromFull(GetFullType(data))
+}
+
+func GetShortTypeFromFull(fullType string) string {
+	parts := strings.Split(fullType, "/")
 	return parts[len(parts)-1]
 }
 

vendor/github.com/rancher/norman/types/reflection.go

@@ -176,9 +176,9 @@ func (s *Schemas) importType(version *APIVersion, t reflect.Type, overrides ...r
 	s.setupFilters(schema)
 
 	schema.Mapper = mapper
-	s.AddSchema(schema)
+	s.AddSchema(*schema)
 
-	return schema, s.Err()
+	return s.Schema(&schema.Version, schema.ID), s.Err()
 }
 
 func jsonName(f reflect.StructField) string {

vendor/github.com/rancher/norman/types/schemas.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/rancher/norman/name"
 	"github.com/rancher/norman/types/convert"
+	"github.com/rancher/norman/types/definition"
 )
 
 type SchemaCollection struct {
@@ -17,10 +18,16 @@ type SchemaInitFunc func(*Schemas) *Schemas
 
 type MappersFactory func() []Mapper
 
+type BackReference struct {
+	FieldName string
+	Schema    *Schema
+}
+
 type Schemas struct {
 	schemasByPath       map[string]map[string]*Schema
 	schemasBySubContext map[string]*Schema
 	mappers             map[string]map[string][]Mapper
+	references          map[string][]BackReference
 	DefaultMappers      MappersFactory
 	DefaultPostMappers  MappersFactory
 	versions            []APIVersion
@@ -33,6 +40,7 @@ func NewSchemas() *Schemas {
 		schemasByPath:       map[string]map[string]*Schema{},
 		schemasBySubContext: map[string]*Schema{},
 		mappers:             map[string]map[string][]Mapper{},
+		references:          map[string][]BackReference{},
 	}
 }
 
@@ -54,12 +62,12 @@ func (s *Schemas) SubContextSchemas() map[string]*Schema {
 
 func (s *Schemas) AddSchemas(schema *Schemas) *Schemas {
 	for _, schema := range schema.Schemas() {
-		s.AddSchema(schema)
+		s.AddSchema(*schema)
 	}
 	return s
 }
 
-func (s *Schemas) AddSchema(schema *Schema) *Schemas {
+func (s *Schemas) AddSchema(schema Schema) *Schemas {
 	schema.Type = "/meta/schemas/schema"
 	if schema.ID == "" {
 		s.errors = append(s.errors, fmt.Errorf("ID is not set on schema: %v", schema))
@@ -90,17 +98,38 @@ func (s *Schemas) AddSchema(schema *Schema) *Schemas {
 	}
 
 	if _, ok := schemas[schema.ID]; !ok {
-		schemas[schema.ID] = schema
-		s.schemas = append(s.schemas, schema)
+		schemas[schema.ID] = &schema
+		s.schemas = append(s.schemas, &schema)
+
+		for name, field := range schema.ResourceFields {
+			if !definition.IsReferenceType(field.Type) {
+				continue
+			}
+
+			refType := definition.SubType(field.Type)
+			if !strings.HasPrefix(refType, "/") {
+				refType = convert.ToFullReference(schema.Version.Path, refType)
+			}
+
+			s.references[refType] = append(s.references[refType], BackReference{
+				FieldName: name,
+				Schema:    &schema,
+			})
+		}
 	}
 
 	if schema.SubContext != "" {
-		s.schemasBySubContext[schema.SubContext] = schema
+		s.schemasBySubContext[schema.SubContext] = &schema
 	}
 
 	return s
 }
 
+func (s *Schemas) References(schema *Schema) []BackReference {
+	refType := convert.ToFullReference(schema.Version.Path, schema.ID)
+	return s.references[refType]
+}
+
 func (s *Schemas) AddMapper(version *APIVersion, schemaID string, mapper Mapper) *Schemas {
 	mappers, ok := s.mappers[version.Path]
 	if !ok {

vendor/github.com/rancher/norman/types/server_types.go

@@ -147,6 +147,7 @@ type URLBuilder interface {
 	ReverseSort(order SortOrder) string
 	Sort(field string) string
 	SetSubContext(subContext string)
+	FilterLink(schema *Schema, fieldName string, value string) string
 }
 
 type Store interface {

vendor/github.com/rancher/types/.gitignore

@@ -4,3 +4,4 @@
 *.swp
 /.trash-cache
 /.idea
+types

vendor/github.com/rancher/types/apis/management.cattle.io/v3/auth_types.go

@@ -1,66 +0,0 @@
-package v3
-
-import (
-	extv1 "k8s.io/api/extensions/v1beta1"
-	rbacv1 "k8s.io/api/rbac/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type Project struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec ProjectSpec `json:"spec,omitempty"`
-}
-
-type ProjectSpec struct {
-	DisplayName string `json:"displayName,omitempty" norman:"required"`
-	ClusterName string `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
-}
-
-type ProjectRoleTemplate struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Rules   []rbacv1.PolicyRule `json:"rules,omitempty"`
-	Builtin bool                `json:"builtin"`
-
-	ProjectRoleTemplateNames []string `json:"projectRoleTemplateNames,omitempty" norman:"type=array[reference[projectRoleTemplate]]"`
-}
-
-type PodSecurityPolicyTemplate struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec extv1.PodSecurityPolicySpec `json:"spec,omitempty"`
-}
-
-type ProjectRoleTemplateBinding struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Subject rbacv1.Subject `json:"subject,omitempty"`
-
-	ProjectName             string `json:"projectName,omitempty" norman:"type=reference[project]"`
-	ProjectRoleTemplateName string `json:"projectRoleTemplateName,omitempty" norman:"type=reference[projectRoleTemplate]"`
-}
-
-type ClusterRoleTemplate struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Rules   []rbacv1.PolicyRule `json:"rules,omitempty"`
-	Builtin bool                `json:"builtin"`
-
-	ClusterRoleTemplateNames []string `json:"clusterRoleTemplateNames,omitempty" norman:"type=array[reference[clusterRoleTemplate]]"`
-}
-
-type ClusterRoleTemplateBinding struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Subject rbacv1.Subject `json:"subject,omitempty"`
-
-	ClusterName             string `json:"clusterName,omitempty" norman:"type=reference[cluster]"`
-	ClusterRoleTemplateName string `json:"clusterRoleTemplateName,omitempty" norman:"type=reference[clusterRoleTemplate]"`
-}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/authn_types.go

@@ -0,0 +1,79 @@
+package v3
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type Token struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	TokenID                  string            `json:"tokenId,omitempty"`
+	UserIdentity             Identity          `json:"userIdentity,omitempty"`
+	GroupIdentities          []Identity        `json:"groupIdentities,omitempty"`
+	ProviderInfo             map[string]string `json:"providerInfo,omitempty"`
+	User                     string            `json:"user,omitempty"`
+	ExternalID               string            `json:"externalId,omitempty"`
+	AuthProvider             string            `json:"authProvider,omitempty"`
+	TTLMillis                string            `json:"ttl,omitempty"`
+	IdentityRefreshTTLMillis string            `json:"identityRefreshTTL,omitempty"`
+	LastUpdateTime           string            `json:"lastUpdateTime,omitempty"`
+	IsDerived                bool              `json:"isDerived,omitempty"`
+	Description              string            `json:"description,omitempty"`
+}
+
+type User struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Secret     string `json:"secret,omitempty"`
+	ExternalID string `json:"externalId,omitempty"`
+}
+
+type Group struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+}
+
+type GroupMember struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	GroupName  string `json:"groupName,omitempty" norman:"type=reference[group]"`
+	ExternalID string `json:"externalId,omitempty"`
+}
+
+type Identity struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	DisplayName    string            `json:"displayName,omitempty"`
+	LoginName      string            `json:"loginName,omitempty"`
+	ProfilePicture string            `json:"profilePicture,omitempty"`
+	ProfileURL     string            `json:"profileURL,omitempty"`
+	Kind           string            `json:"kind,omitempty"`
+	Me             bool              `json:"me,omitempty"`
+	MemberOf       bool              `json:"memberOf,omitempty"`
+	ExtraInfo      map[string]string `json:"extraInfo,omitempty"`
+}
+
+//LoginInput structure defines all properties that can be sent by client to create a token
+type LoginInput struct {
+	TTLMillis                string           `json:"ttl,omitempty"`
+	IdentityRefreshTTLMillis string           `json:"identityRefreshTTL,omitempty"`
+	Description              string           `json:"description,omitempty"`
+	ResponseType             string           `json:"responseType,omitempty"` //json or cookie
+	LocalCredential          LocalCredential  `json:"localCredential, omitempty"`
+	GithubCredential         GithubCredential `json:"githubCredential, omitempty"`
+}
+
+//LocalCredential stores the local auth creds
+type LocalCredential struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+//GithubCredential stores the github auth creds
+type GithubCredential struct {
+	Code string `json:"code"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/authz_types.go

@@ -0,0 +1,57 @@
+package v3
+
+import (
+	extv1 "k8s.io/api/extensions/v1beta1"
+	rbacv1 "k8s.io/api/rbac/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type Project struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec ProjectSpec `json:"spec,omitempty"`
+}
+
+type ProjectSpec struct {
+	DisplayName                   string `json:"displayName,omitempty" norman:"required"`
+	ClusterName                   string `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
+	PodSecurityPolicyTemplateName string `json:"podSecurityPolicyTemplateName,omitempty" norman:"type=reference[podSecurityPolicyTemplate]"`
+}
+
+type RoleTemplate struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Rules   []rbacv1.PolicyRule `json:"rules,omitempty"`
+	Builtin bool                `json:"builtin"`
+
+	RoleTemplateNames []string `json:"roleTemplateNames,omitempty" norman:"type=array[reference[roleTemplate]]"`
+}
+
+type PodSecurityPolicyTemplate struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec extv1.PodSecurityPolicySpec `json:"spec,omitempty"`
+}
+
+type ProjectRoleTemplateBinding struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Subject rbacv1.Subject `json:"subject,omitempty"`
+
+	ProjectName      string `json:"projectName,omitempty" norman:"type=reference[project]"`
+	RoleTemplateName string `json:"roleTemplateName,omitempty" norman:"type=reference[roleTemplate]"`
+}
+
+type ClusterRoleTemplateBinding struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Subject rbacv1.Subject `json:"subject,omitempty"`
+
+	ClusterName      string `json:"clusterName,omitempty" norman:"type=reference[cluster]"`
+	RoleTemplateName string `json:"roleTemplateName,omitempty" norman:"type=reference[roleTemplate]"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/catalog_types.go

@@ -0,0 +1,114 @@
+package v3
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type Catalog struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Specification of the desired behavior of the the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec   CatalogSpec   `json:"spec"`
+	Status CatalogStatus `json:"status"`
+}
+
+type CatalogSpec struct {
+	URL         string `json:"url,omitempty"`
+	Branch      string `json:"branch,omitempty"`
+	CatalogKind string `json:"catalogKind,omitempty"`
+}
+
+type CatalogStatus struct {
+	Commit string `json:"commit,omitempty"`
+}
+
+type Template struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Specification of the desired behavior of the the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec   TemplateSpec   `json:"spec"`
+	Status TemplateStatus `json:"status"`
+}
+
+type TemplateSpec struct {
+	CatalogName string `json:"catalogName,omitempty"`
+
+	IsSystem       string `json:"isSystem,omitempty"`
+	Description    string `json:"description,omitempty"`
+	DefaultVersion string `json:"defaultVersion,omitempty" yaml:"default_version,omitempty"`
+	Path           string `json:"path,omitempty"`
+	Maintainer     string `json:"maintainer,omitempty"`
+	License        string `json:"license,omitempty"`
+	ProjectURL     string `json:"projectURL,omitempty" yaml:"project_url,omitempty"`
+	UpgradeFrom    string `json:"upgradeFrom,omitempty"`
+	FolderName     string `json:"folderName,omitempty"`
+	Catalog        string `json:"catalogId,omitempty"`
+	Base           string `json:"templateBase,omitempty"`
+	Icon           string `json:"icon,omitempty"`
+	IconFilename   string `json:"iconFilename,omitempty"`
+	Readme         string `json:"readme,omitempty"`
+
+	Categories []string              `json:"categories,omitempty"`
+	Versions   []TemplateVersionSpec `json:"versions,omitempty"`
+
+	Category string `json:"category,omitempty"`
+}
+
+type TemplateStatus struct {
+	// todo:
+}
+
+type TemplateVersion struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Specification of the desired behavior of the the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec   TemplateVersionSpec   `json:"spec"`
+	Status TemplateVersionStatus `json:"status"`
+}
+
+type TemplateVersionSpec struct {
+	Revision              *int   `json:"revision,omitempty"`
+	Version               string `json:"version,omitempty"`
+	MinimumRancherVersion string `json:"minimumRancherVersion,omitempty" yaml:"minimum_rancher_version,omitempty"`
+	MaximumRancherVersion string `json:"maximumRancherVersion,omitempty" yaml:"maximum_rancher_version,omitempty"`
+	UpgradeFrom           string `json:"upgradeFrom,omitempty" yaml:"upgrade_from,omitempty"`
+	Readme                string `json:"readme,omitempty"`
+
+	Files     []File     `json:"files,omitempty"`
+	Questions []Question `json:"questions,omitempty"`
+}
+
+type TemplateVersionStatus struct {
+	// todo
+}
+
+type File struct {
+	Name     string `json:"name,omitempty"`
+	Contents string `json:"contents,omitempty"`
+}
+
+type Question struct {
+	Variable     string   `json:"variable,omitempty" yaml:"variable,omitempty"`
+	Label        string   `json:"label,omitempty" yaml:"label,omitempty"`
+	Description  string   `json:"description,omitempty" yaml:"description,omitempty"`
+	Type         string   `json:"type,omitempty" yaml:"type,omitempty"`
+	Required     bool     `json:"required,omitempty" yaml:"required,omitempty"`
+	Default      string   `json:"default,omitempty" yaml:"default,omitempty"`
+	Group        string   `json:"group,omitempty" yaml:"group,omitempty"`
+	MinLength    int      `json:"minLength,omitempty" yaml:"min_length,omitempty"`
+	MaxLength    int      `json:"maxLength,omitempty" yaml:"max_length,omitempty"`
+	Min          int      `json:"min,omitempty" yaml:"min,omitempty"`
+	Max          int      `json:"max,omitempty" yaml:"max,omitempty"`
+	Options      []string `json:"options,omitempty" yaml:"options,omitempty"`
+	ValidChars   string   `json:"validChars,omitempty" yaml:"valid_chars,omitempty"`
+	InvalidChars string   `json:"invalidChars,omitempty" yaml:"invalid_chars,omitempty"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/cluster_types.go

@@ -35,11 +35,12 @@ type Cluster struct {
 }
 
 type ClusterSpec struct {
-	DisplayName                   string                         `json:"displayName"`
-	Description                   string                         `json:"description"`
-	GoogleKubernetesEngineConfig  *GoogleKubernetesEngineConfig  `json:"googleKubernetesEngineConfig,omitempty"`
-	AzureKubernetesServiceConfig  *AzureKubernetesServiceConfig  `json:"azureKubernetesServiceConfig,omitempty"`
-	RancherKubernetesEngineConfig *RancherKubernetesEngineConfig `json:"rancherKubernetesEngineConfig,omitempty"`
+	Description                          string                         `json:"description"`
+	Internal                             bool                           `json:"internal" norman:"nocreate,noupdate"`
+	GoogleKubernetesEngineConfig         *GoogleKubernetesEngineConfig  `json:"googleKubernetesEngineConfig,omitempty"`
+	AzureKubernetesServiceConfig         *AzureKubernetesServiceConfig  `json:"azureKubernetesServiceConfig,omitempty"`
+	RancherKubernetesEngineConfig        *RancherKubernetesEngineConfig `json:"rancherKubernetesEngineConfig,omitempty"`
+	DefaultPodSecurityPolicyTemplateName string                         `json:"defaultPodSecurityPolicyTemplateName,omitempty" norman:"type=reference[podSecurityPolicyTemplate]"`
 }
 
 type ClusterStatus struct {
@@ -103,8 +104,53 @@ type GoogleKubernetesEngineConfig struct {
 	Credential string `json:"credential,omitempty"`
 	// Enable alpha feature
 	EnableAlphaFeature bool `json:"enableAlphaFeature,omitempty"`
+	// Configuration for the HTTP (L7) load balancing controller addon
+	HTTPLoadBalancing bool `json:"httpLoadBalancing,omitempty"`
+	// Configuration for the horizontal pod autoscaling feature, which increases or decreases the number of replica pods a replication controller has based on the resource usage of the existing pods
+	HorizontalPodAutoscaling bool `json:"horizontalPodAutoscaling,omitempty"`
+	// Configuration for the Kubernetes Dashboard
+	KubernetesDashboard bool `json:"kubernetesDashboard,omitempty"`
+	// Configuration for NetworkPolicy
+	NetworkPolicyConfig bool `json:"networkPolicyConfig,omitempty"`
+	// The list of Google Compute Engine locations in which the cluster's nodes should be located
+	Locations []string `json:"locations,omitempty"`
+	// Image Type
+	ImageType string `json:"imageType,omitempty"`
+	// Network
+	Network string `json:"network,omitempty"`
+	// Sub Network
+	SubNetwork string `json:"subNetwork,omitempty"`
+	// Configuration for LegacyAbac
+	LegacyAbac bool `json:"legacyAbac,omitempty"`
 }
 
 type AzureKubernetesServiceConfig struct {
 	//TBD
 }
+
+type ClusterEvent struct {
+	v1.Event
+	ClusterName string `json:"clusterName" norman:"type=reference[cluster]"`
+}
+
+type ClusterRegistrationToken struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Specification of the desired behavior of the the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec ClusterRegistrationTokenSpec `json:"spec"`
+	// Most recent observed status of the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Status ClusterRegistrationTokenStatus `json:"status"`
+}
+
+type ClusterRegistrationTokenSpec struct {
+}
+
+type ClusterRegistrationTokenStatus struct {
+	Command     string `json:"command"`
+	ManifestURL string `json:"manifestUrl"`
+	Token       string `json:"token"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/machine_types.go

@@ -59,11 +59,17 @@ type Machine struct {
 }
 
 type MachineStatus struct {
-	Conditions []MachineCondition `json:"conditions"`
-	NodeStatus v1.NodeStatus      `json:"nodeStatus"`
-	NodeName   string             `json:"nodeName"`
-	Requested  v1.ResourceList    `json:"requested,omitempty"`
-	Limits     v1.ResourceList    `json:"limits,omitempty"`
+	Conditions      []MachineCondition `json:"conditions"`
+	NodeStatus      v1.NodeStatus      `json:"nodeStatus"`
+	NodeName        string             `json:"nodeName"`
+	Requested       v1.ResourceList    `json:"requested,omitempty"`
+	Limits          v1.ResourceList    `json:"limits,omitempty"`
+	Provisioned     bool               `json:"provisioned,omitempty"`
+	SSHUser         string             `json:"sshUser,omitempty"`
+	SSHPrivateKey   string             `json:"sshPrivateKey,omitempty"`
+	ExtractedConfig string             `json:"extractedConfig,omitempty"`
+	Address         string             `json:"address,omitempty"`
+	NodeConfig      *RKEConfigNode     `json:"nodeConfig,omitempty"`
 }
 
 type MachineCondition struct {
@@ -93,12 +99,137 @@ type MachineSpec struct {
 }
 
 type AmazonEC2Config struct {
+	AccessKey string `json:"accessKey,omitempty"`
+
+	Ami string `json:"ami,omitempty"`
+
+	BlockDurationMinutes string `json:"blockDurationMinutes,omitempty"`
+
+	DeviceName string `json:"deviceName,omitempty"`
+
+	Endpoint string `json:"endpoint,omitempty"`
+
+	IamInstanceProfile string `json:"iamInstanceProfile,omitempty"`
+
+	InsecureTransport bool `json:"insecureTransport,omitempty"`
+
+	InstanceType string `json:"instanceType,omitempty"`
+
+	KeypairName string `json:"keypairName,omitempty"`
+
+	Monitoring bool `json:"monitoring,omitempty"`
+
+	OpenPort []string `json:"openPort,omitempty"`
+
+	PrivateAddressOnly bool `json:"privateAddressOnly,omitempty"`
+
+	Region string `json:"region,omitempty"`
+
+	RequestSpotInstance bool `json:"requestSpotInstance,omitempty"`
+
+	Retries string `json:"retries,omitempty"`
+
+	RootSize string `json:"rootSize,omitempty"`
+
+	SecretKey string `json:"secretKey,omitempty"`
+
+	SecurityGroup []string `json:"securityGroup,omitempty"`
+
+	SessionToken string `json:"sessionToken,omitempty"`
+
+	SpotPrice string `json:"spotPrice,omitempty"`
+
+	SSHKeypath string `json:"sshKeypath,omitempty"`
+
+	SSHUser string `json:"sshUser,omitempty"`
+
+	SubnetID string `json:"subnetId,omitempty"`
+
+	Tags string `json:"tags,omitempty"`
+
+	UseEbsOptimizedInstance bool `json:"useEbsOptimizedInstance,omitempty"`
+
+	UsePrivateAddress bool `json:"usePrivateAddress,omitempty"`
+
+	Userdata string `json:"userdata,omitempty"`
+
+	VolumeType string `json:"volumeType,omitempty"`
+
+	VpcID string `json:"vpcId,omitempty"`
+
+	Zone string `json:"zone,omitempty"`
 }
 
 type AzureConfig struct {
+	AvailabilitySet string `json:"availabilitySet,omitempty"`
+
+	ClientID string `json:"clientId,omitempty"`
+
+	ClientSecret string `json:"clientSecret,omitempty"`
+
+	CustomData string `json:"customData,omitempty"`
+
+	DNS string `json:"dns,omitempty"`
+
+	DockerPort string `json:"dockerPort,omitempty"`
+
+	Environment string `json:"environment,omitempty"`
+
+	Image string `json:"image,omitempty"`
+
+	Location string `json:"location,omitempty"`
+
+	NoPublicIP bool `json:"noPublicIp,omitempty"`
+
+	OpenPort []string `json:"openPort,omitempty"`
+
+	PrivateIPAddress string `json:"privateIpAddress,omitempty"`
+
+	ResourceGroup string `json:"resourceGroup,omitempty"`
+
+	Size string `json:"size,omitempty"`
+
+	SSHUser string `json:"sshUser,omitempty"`
+
+	StaticPublicIP bool `json:"staticPublicIp,omitempty"`
+
+	StorageType string `json:"storageType,omitempty"`
+
+	Subnet string `json:"subnet,omitempty"`
+
+	SubnetPrefix string `json:"subnetPrefix,omitempty"`
+
+	SubscriptionID string `json:"subscriptionId,omitempty"`
+
+	UsePrivateIP bool `json:"usePrivateIp,omitempty"`
+
+	Vnet string `json:"vnet,omitempty"`
 }
 
 type DigitalOceanConfig struct {
+	AccessToken string `json:"accessToken,omitempty"`
+
+	Backups bool `json:"backups,omitempty"`
+
+	Image string `json:"image,omitempty"`
+
+	Ipv6 bool `json:"ipv6,omitempty"`
+
+	PrivateNetworking bool `json:"privateNetworking,omitempty"`
+
+	Region string `json:"region,omitempty"`
+
+	Size string `json:"size,omitempty"`
+
+	SSHKeyFingerprint string `json:"sshKeyFingerprint,omitempty"`
+
+	SSHKeyPath string `json:"sshKeyPath,omitempty"`
+
+	SSHPort string `json:"sshPort,omitempty"`
+
+	SSHUser string `json:"sshUser,omitempty"`
+
+	Userdata string `json:"userdata,omitempty"`
 }
 
 type MachineCommonParams struct {
@@ -145,13 +276,12 @@ type MachineDriverCondition struct {
 }
 
 type MachineDriverSpec struct {
-	DisplayName      string `json:"displayName"`
-	Description      string `json:"description"`
-	URL              string `json:"url"`
-	ExternalID       string `json:"externalId"`
-	Builtin          bool   `json:"builtin"`
-	DefaultActive    bool   `json:"defaultActive"`
-	ActivateOnCreate bool   `json:"activateOnCreate"`
-	Checksum         string `json:"checksum"`
-	UIURL            string `json:"uiUrl"`
+	DisplayName string `json:"displayName"`
+	Description string `json:"description"`
+	URL         string `json:"url"`
+	ExternalID  string `json:"externalId"`
+	Builtin     bool   `json:"builtin"`
+	Active      bool   `json:"active"`
+	Checksum    string `json:"checksum"`
+	UIURL       string `json:"uiUrl"`
 }

vendor/github.com/rancher/types/apis/management.cattle.io/v3/rke_types.go

@@ -8,16 +8,22 @@ type RancherKubernetesEngineConfig struct {
 	// Network configuration used in the kubernetes cluster (flannel, calico)
 	Network NetworkConfig `yaml:"network" json:"network,omitempty"`
 	// Authentication configuration used in the cluster (default: x509)
-	Authentication AuthConfig `yaml:"auth" json:"auth,omitempty"`
+	Authentication AuthnConfig `yaml:"authentication" json:"authentication,omitempty"`
 	// YAML manifest for user provided addons to be deployed on the cluster
 	Addons string `yaml:"addons" json:"addons,omitempty"`
 	// List of images used internally for proxy, cert downlaod and kubedns
 	SystemImages map[string]string `yaml:"system_images" json:"systemImages,omitempty"`
 	// SSH Private Key Path
 	SSHKeyPath string `yaml:"ssh_key_path" json:"sshKeyPath,omitempty"`
+	// Authorization mode configuration used in the cluster
+	Authorization AuthzConfig `yaml:"authorization" json:"authorization,omitempty"`
+	// Enable/disable strict docker version checking
+	IgnoreDockerVersion bool `yaml:"ignore_docker_version" json:"ignoreDockerVersion"`
 }
 
 type RKEConfigNode struct {
+	// Name of the host provisioned via docker machine
+	MachineName string `yaml:"machine_name" json:"machineName, omitempty"`
 	// IP or FQDN that is fully resolvable and used for SSH communication
 	Address string `yaml:"address" json:"address,omitempty"`
 	// Optional - Internal address that will be used for components communication
@@ -107,9 +113,16 @@ type NetworkConfig struct {
 	Options map[string]string `yaml:"options" json:"options,omitempty"`
 }
 
-type AuthConfig struct {
+type AuthnConfig struct {
 	// Authentication strategy that will be used in kubernetes cluster
 	Strategy string `yaml:"strategy" json:"strategy,omitempty"`
 	// Authentication options
 	Options map[string]string `yaml:"options" json:"options,omitempty"`
 }
+
+type AuthzConfig struct {
+	// Authorization mode used by kubernetes
+	Mode string `yaml:"mode" json:"mode,omitempty"`
+	// Authorization mode options
+	Options map[string]string `yaml:"options" json:"options,omitempty"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/schema_types.go

@@ -0,0 +1,72 @@
+package v3
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type DynamicSchema struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object’s metadata. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#metadata
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Specification of the desired behavior of the the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Spec DynamicSchemaSpec `json:"spec"`
+	// Most recent observed status of the cluster. More info:
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
+	Status DynamicSchemaStatus `json:"status"`
+}
+
+type DynamicSchemaSpec struct {
+	PluralName        string            `json:"pluralName,omitempty"`
+	ResourceMethods   []string          `json:"resourceMethods,omitempty"`
+	ResourceFields    map[string]Field  `json:"resourceFields,omitempty"`
+	ResourceActions   map[string]Action `json:"resourceActions,omitempty"`
+	CollectionMethods []string          `json:"collectionMethods,omitempty"`
+	CollectionFields  map[string]Field  `json:"collectionFields,omitempty"`
+	CollectionActions map[string]Action `json:"collectionActions,omitempty"`
+	CollectionFilters map[string]Filter `json:"collectionFilters,omitempty"`
+	IncludeableLinks  []string          `json:"includeableLinks,omitempty"`
+}
+
+type DynamicSchemaStatus struct {
+	Fake string `json:"fake,omitempty"`
+}
+
+type Field struct {
+	Type         string   `json:"type,omitempty"`
+	Default      Values   `json:"default,omitempty"`
+	Unique       bool     `json:"unique,omitempty"`
+	Nullable     bool     `json:"nullable,omitempty"`
+	Create       bool     `json:"create,omitempty"`
+	Required     bool     `json:"required,omitempty"`
+	Update       bool     `json:"update,omitempty"`
+	MinLength    int64    `json:"minLength,omitempty"`
+	MaxLength    int64    `json:"maxLength,omitempty"`
+	Min          int64    `json:"min,omitempty"`
+	Max          int64    `json:"max,omitempty"`
+	Options      []string `json:"options,omitempty"`
+	ValidChars   string   `json:"validChars,omitempty"`
+	InvalidChars string   `json:"invalidChars,omitempty"`
+	Description  string   `json:"description,omitempty"`
+}
+
+type Values struct {
+	StringValue      string   `json:"stringValue,omitempty"`
+	IntValue         int      `json:"intValue,omitempty"`
+	BoolValue        bool     `json:"boolValue,omitempty"`
+	StringSliceValue []string `json:"stringSliceValue,omitempty"`
+}
+
+type Action struct {
+	Input  string `json:"input,omitempty"`
+	Output string `json:"output,omitempty"`
+}
+
+type Filter struct {
+	Modifiers []string `json:"modifiers,omitempty"`
+}
+
+type ListOpts struct {
+	Filters map[string]string `json:"filters,omitempty"`
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_catalog_controller.go

@@ -0,0 +1,193 @@
+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 (
+	CatalogGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "Catalog",
+	}
+	CatalogResource = metav1.APIResource{
+		Name:         "catalogs",
+		SingularName: "catalog",
+		Namespaced:   false,
+		Kind:         CatalogGroupVersionKind.Kind,
+	}
+)
+
+type CatalogList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Catalog
+}
+
+type CatalogHandlerFunc func(key string, obj *Catalog) error
+
+type CatalogLister interface {
+	List(namespace string, selector labels.Selector) (ret []*Catalog, err error)
+	Get(namespace, name string) (*Catalog, error)
+}
+
+type CatalogController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() CatalogLister
+	AddHandler(handler CatalogHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type CatalogInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*Catalog) (*Catalog, error)
+	Get(name string, opts metav1.GetOptions) (*Catalog, error)
+	Update(*Catalog) (*Catalog, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*CatalogList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() CatalogController
+}
+
+type catalogLister struct {
+	controller *catalogController
+}
+
+func (l *catalogLister) List(namespace string, selector labels.Selector) (ret []*Catalog, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*Catalog))
+	})
+	return
+}
+
+func (l *catalogLister) Get(namespace, name string) (*Catalog, 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:    CatalogGroupVersionKind.Group,
+			Resource: "catalog",
+		}, name)
+	}
+	return obj.(*Catalog), nil
+}
+
+type catalogController struct {
+	controller.GenericController
+}
+
+func (c *catalogController) Lister() CatalogLister {
+	return &catalogLister{
+		controller: c,
+	}
+}
+
+func (c *catalogController) AddHandler(handler CatalogHandlerFunc) {
+	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.(*Catalog))
+	})
+}
+
+type catalogFactory struct {
+}
+
+func (c catalogFactory) Object() runtime.Object {
+	return &Catalog{}
+}
+
+func (c catalogFactory) List() runtime.Object {
+	return &CatalogList{}
+}
+
+func (s *catalogClient) Controller() CatalogController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.catalogControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(CatalogGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &catalogController{
+		GenericController: genericController,
+	}
+
+	s.client.catalogControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type catalogClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   CatalogController
+}
+
+func (s *catalogClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *catalogClient) Create(o *Catalog) (*Catalog, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*Catalog), err
+}
+
+func (s *catalogClient) Get(name string, opts metav1.GetOptions) (*Catalog, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*Catalog), err
+}
+
+func (s *catalogClient) Update(o *Catalog) (*Catalog, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*Catalog), err
+}
+
+func (s *catalogClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *catalogClient) List(opts metav1.ListOptions) (*CatalogList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*CatalogList), err
+}
+
+func (s *catalogClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *catalogClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_catalog_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_controller.go

@@ -74,7 +74,13 @@ func (l *clusterLister) List(namespace string, selector labels.Selector) (ret []
 }
 
 func (l *clusterLister) Get(namespace, name string) (*Cluster, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_event_controller.go

@@ -0,0 +1,193 @@
+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 (
+	ClusterEventGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "ClusterEvent",
+	}
+	ClusterEventResource = metav1.APIResource{
+		Name:         "clusterevents",
+		SingularName: "clusterevent",
+		Namespaced:   false,
+		Kind:         ClusterEventGroupVersionKind.Kind,
+	}
+)
+
+type ClusterEventList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []ClusterEvent
+}
+
+type ClusterEventHandlerFunc func(key string, obj *ClusterEvent) error
+
+type ClusterEventLister interface {
+	List(namespace string, selector labels.Selector) (ret []*ClusterEvent, err error)
+	Get(namespace, name string) (*ClusterEvent, error)
+}
+
+type ClusterEventController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() ClusterEventLister
+	AddHandler(handler ClusterEventHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type ClusterEventInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*ClusterEvent) (*ClusterEvent, error)
+	Get(name string, opts metav1.GetOptions) (*ClusterEvent, error)
+	Update(*ClusterEvent) (*ClusterEvent, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*ClusterEventList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() ClusterEventController
+}
+
+type clusterEventLister struct {
+	controller *clusterEventController
+}
+
+func (l *clusterEventLister) List(namespace string, selector labels.Selector) (ret []*ClusterEvent, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*ClusterEvent))
+	})
+	return
+}
+
+func (l *clusterEventLister) Get(namespace, name string) (*ClusterEvent, 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:    ClusterEventGroupVersionKind.Group,
+			Resource: "clusterEvent",
+		}, name)
+	}
+	return obj.(*ClusterEvent), nil
+}
+
+type clusterEventController struct {
+	controller.GenericController
+}
+
+func (c *clusterEventController) Lister() ClusterEventLister {
+	return &clusterEventLister{
+		controller: c,
+	}
+}
+
+func (c *clusterEventController) AddHandler(handler ClusterEventHandlerFunc) {
+	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.(*ClusterEvent))
+	})
+}
+
+type clusterEventFactory struct {
+}
+
+func (c clusterEventFactory) Object() runtime.Object {
+	return &ClusterEvent{}
+}
+
+func (c clusterEventFactory) List() runtime.Object {
+	return &ClusterEventList{}
+}
+
+func (s *clusterEventClient) Controller() ClusterEventController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.clusterEventControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(ClusterEventGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &clusterEventController{
+		GenericController: genericController,
+	}
+
+	s.client.clusterEventControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type clusterEventClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   ClusterEventController
+}
+
+func (s *clusterEventClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *clusterEventClient) Create(o *ClusterEvent) (*ClusterEvent, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*ClusterEvent), err
+}
+
+func (s *clusterEventClient) Get(name string, opts metav1.GetOptions) (*ClusterEvent, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*ClusterEvent), err
+}
+
+func (s *clusterEventClient) Update(o *ClusterEvent) (*ClusterEvent, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*ClusterEvent), err
+}
+
+func (s *clusterEventClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *clusterEventClient) List(opts metav1.ListOptions) (*ClusterEventList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*ClusterEventList), err
+}
+
+func (s *clusterEventClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *clusterEventClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_event_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type ClusterLifecycle interface {
-	Initialize(obj *Cluster) error
-	Remove(obj *Cluster) error
-	Updated(obj *Cluster) error
+	Create(obj *Cluster) (*Cluster, error)
+	Remove(obj *Cluster) (*Cluster, error)
+	Updated(obj *Cluster) (*Cluster, error)
 }
 
 type clusterLifecycleAdapter struct {
 	lifecycle ClusterLifecycle
 }
 
-func (w *clusterLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*Cluster))
+func (w *clusterLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*Cluster))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *clusterLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*Cluster))
+func (w *clusterLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*Cluster))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *clusterLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*Cluster))
+func (w *clusterLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*Cluster))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewClusterLifecycleAdapter(name string, client ClusterInterface, l ClusterLifecycle) ClusterHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_controller.go

@@ -0,0 +1,193 @@
+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 (
+	ClusterRegistrationTokenGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "ClusterRegistrationToken",
+	}
+	ClusterRegistrationTokenResource = metav1.APIResource{
+		Name:         "clusterregistrationtokens",
+		SingularName: "clusterregistrationtoken",
+		Namespaced:   false,
+		Kind:         ClusterRegistrationTokenGroupVersionKind.Kind,
+	}
+)
+
+type ClusterRegistrationTokenList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []ClusterRegistrationToken
+}
+
+type ClusterRegistrationTokenHandlerFunc func(key string, obj *ClusterRegistrationToken) error
+
+type ClusterRegistrationTokenLister interface {
+	List(namespace string, selector labels.Selector) (ret []*ClusterRegistrationToken, err error)
+	Get(namespace, name string) (*ClusterRegistrationToken, error)
+}
+
+type ClusterRegistrationTokenController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() ClusterRegistrationTokenLister
+	AddHandler(handler ClusterRegistrationTokenHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type ClusterRegistrationTokenInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*ClusterRegistrationToken) (*ClusterRegistrationToken, error)
+	Get(name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error)
+	Update(*ClusterRegistrationToken) (*ClusterRegistrationToken, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*ClusterRegistrationTokenList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() ClusterRegistrationTokenController
+}
+
+type clusterRegistrationTokenLister struct {
+	controller *clusterRegistrationTokenController
+}
+
+func (l *clusterRegistrationTokenLister) List(namespace string, selector labels.Selector) (ret []*ClusterRegistrationToken, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*ClusterRegistrationToken))
+	})
+	return
+}
+
+func (l *clusterRegistrationTokenLister) Get(namespace, name string) (*ClusterRegistrationToken, 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:    ClusterRegistrationTokenGroupVersionKind.Group,
+			Resource: "clusterRegistrationToken",
+		}, name)
+	}
+	return obj.(*ClusterRegistrationToken), nil
+}
+
+type clusterRegistrationTokenController struct {
+	controller.GenericController
+}
+
+func (c *clusterRegistrationTokenController) Lister() ClusterRegistrationTokenLister {
+	return &clusterRegistrationTokenLister{
+		controller: c,
+	}
+}
+
+func (c *clusterRegistrationTokenController) AddHandler(handler ClusterRegistrationTokenHandlerFunc) {
+	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.(*ClusterRegistrationToken))
+	})
+}
+
+type clusterRegistrationTokenFactory struct {
+}
+
+func (c clusterRegistrationTokenFactory) Object() runtime.Object {
+	return &ClusterRegistrationToken{}
+}
+
+func (c clusterRegistrationTokenFactory) List() runtime.Object {
+	return &ClusterRegistrationTokenList{}
+}
+
+func (s *clusterRegistrationTokenClient) Controller() ClusterRegistrationTokenController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.clusterRegistrationTokenControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(ClusterRegistrationTokenGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &clusterRegistrationTokenController{
+		GenericController: genericController,
+	}
+
+	s.client.clusterRegistrationTokenControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type clusterRegistrationTokenClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   ClusterRegistrationTokenController
+}
+
+func (s *clusterRegistrationTokenClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *clusterRegistrationTokenClient) Create(o *ClusterRegistrationToken) (*ClusterRegistrationToken, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*ClusterRegistrationToken), err
+}
+
+func (s *clusterRegistrationTokenClient) Get(name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*ClusterRegistrationToken), err
+}
+
+func (s *clusterRegistrationTokenClient) Update(o *ClusterRegistrationToken) (*ClusterRegistrationToken, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*ClusterRegistrationToken), err
+}
+
+func (s *clusterRegistrationTokenClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *clusterRegistrationTokenClient) List(opts metav1.ListOptions) (*ClusterRegistrationTokenList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*ClusterRegistrationTokenList), err
+}
+
+func (s *clusterRegistrationTokenClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *clusterRegistrationTokenClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_controller.go

@@ -74,7 +74,13 @@ func (l *clusterRoleTemplateBindingLister) List(namespace string, selector label
 }
 
 func (l *clusterRoleTemplateBindingLister) Get(namespace, name string) (*ClusterRoleTemplateBinding, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type ClusterRoleTemplateBindingLifecycle interface {
-	Initialize(obj *ClusterRoleTemplateBinding) error
-	Remove(obj *ClusterRoleTemplateBinding) error
-	Updated(obj *ClusterRoleTemplateBinding) error
+	Create(obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error)
+	Remove(obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error)
+	Updated(obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error)
 }
 
 type clusterRoleTemplateBindingLifecycleAdapter struct {
 	lifecycle ClusterRoleTemplateBindingLifecycle
 }
 
-func (w *clusterRoleTemplateBindingLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*ClusterRoleTemplateBinding))
+func (w *clusterRoleTemplateBindingLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*ClusterRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *clusterRoleTemplateBindingLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*ClusterRoleTemplateBinding))
+func (w *clusterRoleTemplateBindingLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*ClusterRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *clusterRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*ClusterRoleTemplateBinding))
+func (w *clusterRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*ClusterRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewClusterRoleTemplateBindingLifecycleAdapter(name string, client ClusterRoleTemplateBindingInterface, l ClusterRoleTemplateBindingLifecycle) ClusterRoleTemplateBindingHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_role_template_controller.go

@@ -1,187 +0,0 @@
-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 (
-	ClusterRoleTemplateGroupVersionKind = schema.GroupVersionKind{
-		Version: "v3",
-		Group:   "management.cattle.io",
-		Kind:    "ClusterRoleTemplate",
-	}
-	ClusterRoleTemplateResource = metav1.APIResource{
-		Name:         "clusterroletemplates",
-		SingularName: "clusterroletemplate",
-		Namespaced:   false,
-		Kind:         ClusterRoleTemplateGroupVersionKind.Kind,
-	}
-)
-
-type ClusterRoleTemplateList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []ClusterRoleTemplate
-}
-
-type ClusterRoleTemplateHandlerFunc func(key string, obj *ClusterRoleTemplate) error
-
-type ClusterRoleTemplateLister interface {
-	List(namespace string, selector labels.Selector) (ret []*ClusterRoleTemplate, err error)
-	Get(namespace, name string) (*ClusterRoleTemplate, error)
-}
-
-type ClusterRoleTemplateController interface {
-	Informer() cache.SharedIndexInformer
-	Lister() ClusterRoleTemplateLister
-	AddHandler(handler ClusterRoleTemplateHandlerFunc)
-	Enqueue(namespace, name string)
-	Sync(ctx context.Context) error
-	Start(ctx context.Context, threadiness int) error
-}
-
-type ClusterRoleTemplateInterface interface {
-	ObjectClient() *clientbase.ObjectClient
-	Create(*ClusterRoleTemplate) (*ClusterRoleTemplate, error)
-	Get(name string, opts metav1.GetOptions) (*ClusterRoleTemplate, error)
-	Update(*ClusterRoleTemplate) (*ClusterRoleTemplate, error)
-	Delete(name string, options *metav1.DeleteOptions) error
-	List(opts metav1.ListOptions) (*ClusterRoleTemplateList, error)
-	Watch(opts metav1.ListOptions) (watch.Interface, error)
-	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Controller() ClusterRoleTemplateController
-}
-
-type clusterRoleTemplateLister struct {
-	controller *clusterRoleTemplateController
-}
-
-func (l *clusterRoleTemplateLister) List(namespace string, selector labels.Selector) (ret []*ClusterRoleTemplate, err error) {
-	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
-		ret = append(ret, obj.(*ClusterRoleTemplate))
-	})
-	return
-}
-
-func (l *clusterRoleTemplateLister) Get(namespace, name string) (*ClusterRoleTemplate, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(schema.GroupResource{
-			Group:    ClusterRoleTemplateGroupVersionKind.Group,
-			Resource: "clusterRoleTemplate",
-		}, name)
-	}
-	return obj.(*ClusterRoleTemplate), nil
-}
-
-type clusterRoleTemplateController struct {
-	controller.GenericController
-}
-
-func (c *clusterRoleTemplateController) Lister() ClusterRoleTemplateLister {
-	return &clusterRoleTemplateLister{
-		controller: c,
-	}
-}
-
-func (c *clusterRoleTemplateController) AddHandler(handler ClusterRoleTemplateHandlerFunc) {
-	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.(*ClusterRoleTemplate))
-	})
-}
-
-type clusterRoleTemplateFactory struct {
-}
-
-func (c clusterRoleTemplateFactory) Object() runtime.Object {
-	return &ClusterRoleTemplate{}
-}
-
-func (c clusterRoleTemplateFactory) List() runtime.Object {
-	return &ClusterRoleTemplateList{}
-}
-
-func (s *clusterRoleTemplateClient) Controller() ClusterRoleTemplateController {
-	s.client.Lock()
-	defer s.client.Unlock()
-
-	c, ok := s.client.clusterRoleTemplateControllers[s.ns]
-	if ok {
-		return c
-	}
-
-	genericController := controller.NewGenericController(ClusterRoleTemplateGroupVersionKind.Kind+"Controller",
-		s.objectClient)
-
-	c = &clusterRoleTemplateController{
-		GenericController: genericController,
-	}
-
-	s.client.clusterRoleTemplateControllers[s.ns] = c
-	s.client.starters = append(s.client.starters, c)
-
-	return c
-}
-
-type clusterRoleTemplateClient struct {
-	client       *Client
-	ns           string
-	objectClient *clientbase.ObjectClient
-	controller   ClusterRoleTemplateController
-}
-
-func (s *clusterRoleTemplateClient) ObjectClient() *clientbase.ObjectClient {
-	return s.objectClient
-}
-
-func (s *clusterRoleTemplateClient) Create(o *ClusterRoleTemplate) (*ClusterRoleTemplate, error) {
-	obj, err := s.objectClient.Create(o)
-	return obj.(*ClusterRoleTemplate), err
-}
-
-func (s *clusterRoleTemplateClient) Get(name string, opts metav1.GetOptions) (*ClusterRoleTemplate, error) {
-	obj, err := s.objectClient.Get(name, opts)
-	return obj.(*ClusterRoleTemplate), err
-}
-
-func (s *clusterRoleTemplateClient) Update(o *ClusterRoleTemplate) (*ClusterRoleTemplate, error) {
-	obj, err := s.objectClient.Update(o.Name, o)
-	return obj.(*ClusterRoleTemplate), err
-}
-
-func (s *clusterRoleTemplateClient) Delete(name string, options *metav1.DeleteOptions) error {
-	return s.objectClient.Delete(name, options)
-}
-
-func (s *clusterRoleTemplateClient) List(opts metav1.ListOptions) (*ClusterRoleTemplateList, error) {
-	obj, err := s.objectClient.List(opts)
-	return obj.(*ClusterRoleTemplateList), err
-}
-
-func (s *clusterRoleTemplateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
-	return s.objectClient.Watch(opts)
-}
-
-func (s *clusterRoleTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
-}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_cluster_role_template_lifecycle_adapter.go

@@ -1,39 +0,0 @@
-package v3
-
-import (
-	"github.com/rancher/norman/lifecycle"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-type ClusterRoleTemplateLifecycle interface {
-	Initialize(obj *ClusterRoleTemplate) error
-	Remove(obj *ClusterRoleTemplate) error
-	Updated(obj *ClusterRoleTemplate) error
-}
-
-type clusterRoleTemplateLifecycleAdapter struct {
-	lifecycle ClusterRoleTemplateLifecycle
-}
-
-func (w *clusterRoleTemplateLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*ClusterRoleTemplate))
-}
-
-func (w *clusterRoleTemplateLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*ClusterRoleTemplate))
-}
-
-func (w *clusterRoleTemplateLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*ClusterRoleTemplate))
-}
-
-func NewClusterRoleTemplateLifecycleAdapter(name string, client ClusterRoleTemplateInterface, l ClusterRoleTemplateLifecycle) ClusterRoleTemplateHandlerFunc {
-	adapter := &clusterRoleTemplateLifecycleAdapter{lifecycle: l}
-	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
-	return func(key string, obj *ClusterRoleTemplate) error {
-		if obj == nil {
-			return syncFn(key, nil)
-		}
-		return syncFn(key, obj)
-	}
-}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_dynamic_schema_controller.go

@@ -0,0 +1,193 @@
+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 (
+	DynamicSchemaGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "DynamicSchema",
+	}
+	DynamicSchemaResource = metav1.APIResource{
+		Name:         "dynamicschemas",
+		SingularName: "dynamicschema",
+		Namespaced:   false,
+		Kind:         DynamicSchemaGroupVersionKind.Kind,
+	}
+)
+
+type DynamicSchemaList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []DynamicSchema
+}
+
+type DynamicSchemaHandlerFunc func(key string, obj *DynamicSchema) error
+
+type DynamicSchemaLister interface {
+	List(namespace string, selector labels.Selector) (ret []*DynamicSchema, err error)
+	Get(namespace, name string) (*DynamicSchema, error)
+}
+
+type DynamicSchemaController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() DynamicSchemaLister
+	AddHandler(handler DynamicSchemaHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type DynamicSchemaInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*DynamicSchema) (*DynamicSchema, error)
+	Get(name string, opts metav1.GetOptions) (*DynamicSchema, error)
+	Update(*DynamicSchema) (*DynamicSchema, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*DynamicSchemaList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() DynamicSchemaController
+}
+
+type dynamicSchemaLister struct {
+	controller *dynamicSchemaController
+}
+
+func (l *dynamicSchemaLister) List(namespace string, selector labels.Selector) (ret []*DynamicSchema, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*DynamicSchema))
+	})
+	return
+}
+
+func (l *dynamicSchemaLister) Get(namespace, name string) (*DynamicSchema, 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:    DynamicSchemaGroupVersionKind.Group,
+			Resource: "dynamicSchema",
+		}, name)
+	}
+	return obj.(*DynamicSchema), nil
+}
+
+type dynamicSchemaController struct {
+	controller.GenericController
+}
+
+func (c *dynamicSchemaController) Lister() DynamicSchemaLister {
+	return &dynamicSchemaLister{
+		controller: c,
+	}
+}
+
+func (c *dynamicSchemaController) AddHandler(handler DynamicSchemaHandlerFunc) {
+	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.(*DynamicSchema))
+	})
+}
+
+type dynamicSchemaFactory struct {
+}
+
+func (c dynamicSchemaFactory) Object() runtime.Object {
+	return &DynamicSchema{}
+}
+
+func (c dynamicSchemaFactory) List() runtime.Object {
+	return &DynamicSchemaList{}
+}
+
+func (s *dynamicSchemaClient) Controller() DynamicSchemaController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.dynamicSchemaControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(DynamicSchemaGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &dynamicSchemaController{
+		GenericController: genericController,
+	}
+
+	s.client.dynamicSchemaControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type dynamicSchemaClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   DynamicSchemaController
+}
+
+func (s *dynamicSchemaClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *dynamicSchemaClient) Create(o *DynamicSchema) (*DynamicSchema, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*DynamicSchema), err
+}
+
+func (s *dynamicSchemaClient) Get(name string, opts metav1.GetOptions) (*DynamicSchema, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*DynamicSchema), err
+}
+
+func (s *dynamicSchemaClient) Update(o *DynamicSchema) (*DynamicSchema, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*DynamicSchema), err
+}
+
+func (s *dynamicSchemaClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *dynamicSchemaClient) List(opts metav1.ListOptions) (*DynamicSchemaList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*DynamicSchemaList), err
+}
+
+func (s *dynamicSchemaClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *dynamicSchemaClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_dynamic_schema_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_group_controller.go

@@ -0,0 +1,193 @@
+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 (
+	GroupGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "Group",
+	}
+	GroupResource = metav1.APIResource{
+		Name:         "groups",
+		SingularName: "group",
+		Namespaced:   false,
+		Kind:         GroupGroupVersionKind.Kind,
+	}
+)
+
+type GroupList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Group
+}
+
+type GroupHandlerFunc func(key string, obj *Group) error
+
+type GroupLister interface {
+	List(namespace string, selector labels.Selector) (ret []*Group, err error)
+	Get(namespace, name string) (*Group, error)
+}
+
+type GroupController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() GroupLister
+	AddHandler(handler GroupHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type GroupInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*Group) (*Group, error)
+	Get(name string, opts metav1.GetOptions) (*Group, error)
+	Update(*Group) (*Group, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*GroupList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() GroupController
+}
+
+type groupLister struct {
+	controller *groupController
+}
+
+func (l *groupLister) List(namespace string, selector labels.Selector) (ret []*Group, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*Group))
+	})
+	return
+}
+
+func (l *groupLister) Get(namespace, name string) (*Group, 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:    GroupGroupVersionKind.Group,
+			Resource: "group",
+		}, name)
+	}
+	return obj.(*Group), nil
+}
+
+type groupController struct {
+	controller.GenericController
+}
+
+func (c *groupController) Lister() GroupLister {
+	return &groupLister{
+		controller: c,
+	}
+}
+
+func (c *groupController) AddHandler(handler GroupHandlerFunc) {
+	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.(*Group))
+	})
+}
+
+type groupFactory struct {
+}
+
+func (c groupFactory) Object() runtime.Object {
+	return &Group{}
+}
+
+func (c groupFactory) List() runtime.Object {
+	return &GroupList{}
+}
+
+func (s *groupClient) Controller() GroupController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.groupControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(GroupGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &groupController{
+		GenericController: genericController,
+	}
+
+	s.client.groupControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type groupClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   GroupController
+}
+
+func (s *groupClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *groupClient) Create(o *Group) (*Group, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*Group), err
+}
+
+func (s *groupClient) Get(name string, opts metav1.GetOptions) (*Group, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*Group), err
+}
+
+func (s *groupClient) Update(o *Group) (*Group, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*Group), err
+}
+
+func (s *groupClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *groupClient) List(opts metav1.ListOptions) (*GroupList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*GroupList), err
+}
+
+func (s *groupClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *groupClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_group_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_group_member_controller.go

@@ -0,0 +1,193 @@
+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 (
+	GroupMemberGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "GroupMember",
+	}
+	GroupMemberResource = metav1.APIResource{
+		Name:         "groupmembers",
+		SingularName: "groupmember",
+		Namespaced:   false,
+		Kind:         GroupMemberGroupVersionKind.Kind,
+	}
+)
+
+type GroupMemberList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []GroupMember
+}
+
+type GroupMemberHandlerFunc func(key string, obj *GroupMember) error
+
+type GroupMemberLister interface {
+	List(namespace string, selector labels.Selector) (ret []*GroupMember, err error)
+	Get(namespace, name string) (*GroupMember, error)
+}
+
+type GroupMemberController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() GroupMemberLister
+	AddHandler(handler GroupMemberHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type GroupMemberInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*GroupMember) (*GroupMember, error)
+	Get(name string, opts metav1.GetOptions) (*GroupMember, error)
+	Update(*GroupMember) (*GroupMember, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*GroupMemberList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() GroupMemberController
+}
+
+type groupMemberLister struct {
+	controller *groupMemberController
+}
+
+func (l *groupMemberLister) List(namespace string, selector labels.Selector) (ret []*GroupMember, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*GroupMember))
+	})
+	return
+}
+
+func (l *groupMemberLister) Get(namespace, name string) (*GroupMember, 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:    GroupMemberGroupVersionKind.Group,
+			Resource: "groupMember",
+		}, name)
+	}
+	return obj.(*GroupMember), nil
+}
+
+type groupMemberController struct {
+	controller.GenericController
+}
+
+func (c *groupMemberController) Lister() GroupMemberLister {
+	return &groupMemberLister{
+		controller: c,
+	}
+}
+
+func (c *groupMemberController) AddHandler(handler GroupMemberHandlerFunc) {
+	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.(*GroupMember))
+	})
+}
+
+type groupMemberFactory struct {
+}
+
+func (c groupMemberFactory) Object() runtime.Object {
+	return &GroupMember{}
+}
+
+func (c groupMemberFactory) List() runtime.Object {
+	return &GroupMemberList{}
+}
+
+func (s *groupMemberClient) Controller() GroupMemberController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.groupMemberControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(GroupMemberGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &groupMemberController{
+		GenericController: genericController,
+	}
+
+	s.client.groupMemberControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type groupMemberClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   GroupMemberController
+}
+
+func (s *groupMemberClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *groupMemberClient) Create(o *GroupMember) (*GroupMember, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*GroupMember), err
+}
+
+func (s *groupMemberClient) Get(name string, opts metav1.GetOptions) (*GroupMember, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*GroupMember), err
+}
+
+func (s *groupMemberClient) Update(o *GroupMember) (*GroupMember, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*GroupMember), err
+}
+
+func (s *groupMemberClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *groupMemberClient) List(opts metav1.ListOptions) (*GroupMemberList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*GroupMemberList), err
+}
+
+func (s *groupMemberClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *groupMemberClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_group_member_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_identity_controller.go

@@ -0,0 +1,193 @@
+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 (
+	IdentityGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "Identity",
+	}
+	IdentityResource = metav1.APIResource{
+		Name:         "identities",
+		SingularName: "identity",
+		Namespaced:   false,
+		Kind:         IdentityGroupVersionKind.Kind,
+	}
+)
+
+type IdentityList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Identity
+}
+
+type IdentityHandlerFunc func(key string, obj *Identity) error
+
+type IdentityLister interface {
+	List(namespace string, selector labels.Selector) (ret []*Identity, err error)
+	Get(namespace, name string) (*Identity, error)
+}
+
+type IdentityController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() IdentityLister
+	AddHandler(handler IdentityHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type IdentityInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*Identity) (*Identity, error)
+	Get(name string, opts metav1.GetOptions) (*Identity, error)
+	Update(*Identity) (*Identity, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*IdentityList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() IdentityController
+}
+
+type identityLister struct {
+	controller *identityController
+}
+
+func (l *identityLister) List(namespace string, selector labels.Selector) (ret []*Identity, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*Identity))
+	})
+	return
+}
+
+func (l *identityLister) Get(namespace, name string) (*Identity, 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:    IdentityGroupVersionKind.Group,
+			Resource: "identity",
+		}, name)
+	}
+	return obj.(*Identity), nil
+}
+
+type identityController struct {
+	controller.GenericController
+}
+
+func (c *identityController) Lister() IdentityLister {
+	return &identityLister{
+		controller: c,
+	}
+}
+
+func (c *identityController) AddHandler(handler IdentityHandlerFunc) {
+	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.(*Identity))
+	})
+}
+
+type identityFactory struct {
+}
+
+func (c identityFactory) Object() runtime.Object {
+	return &Identity{}
+}
+
+func (c identityFactory) List() runtime.Object {
+	return &IdentityList{}
+}
+
+func (s *identityClient) Controller() IdentityController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.identityControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(IdentityGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &identityController{
+		GenericController: genericController,
+	}
+
+	s.client.identityControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type identityClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   IdentityController
+}
+
+func (s *identityClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *identityClient) Create(o *Identity) (*Identity, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*Identity), err
+}
+
+func (s *identityClient) Get(name string, opts metav1.GetOptions) (*Identity, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*Identity), err
+}
+
+func (s *identityClient) Update(o *Identity) (*Identity, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*Identity), err
+}
+
+func (s *identityClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *identityClient) List(opts metav1.ListOptions) (*IdentityList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*IdentityList), err
+}
+
+func (s *identityClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *identityClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_identity_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_k8s_client.go

@@ -18,12 +18,22 @@ type Interface interface {
 	MachineDriversGetter
 	MachineTemplatesGetter
 	ProjectsGetter
-	ProjectRoleTemplatesGetter
+	RoleTemplatesGetter
 	PodSecurityPolicyTemplatesGetter
-	ClusterRoleTemplatesGetter
 	ClusterRoleTemplateBindingsGetter
 	ProjectRoleTemplateBindingsGetter
 	ClustersGetter
+	ClusterEventsGetter
+	ClusterRegistrationTokensGetter
+	CatalogsGetter
+	TemplatesGetter
+	TemplateVersionsGetter
+	IdentitiesGetter
+	TokensGetter
+	UsersGetter
+	GroupsGetter
+	GroupMembersGetter
+	DynamicSchemasGetter
 }
 
 type Client struct {
@@ -35,12 +45,22 @@ type Client struct {
 	machineDriverControllers              map[string]MachineDriverController
 	machineTemplateControllers            map[string]MachineTemplateController
 	projectControllers                    map[string]ProjectController
-	projectRoleTemplateControllers        map[string]ProjectRoleTemplateController
+	roleTemplateControllers               map[string]RoleTemplateController
 	podSecurityPolicyTemplateControllers  map[string]PodSecurityPolicyTemplateController
-	clusterRoleTemplateControllers        map[string]ClusterRoleTemplateController
 	clusterRoleTemplateBindingControllers map[string]ClusterRoleTemplateBindingController
 	projectRoleTemplateBindingControllers map[string]ProjectRoleTemplateBindingController
 	clusterControllers                    map[string]ClusterController
+	clusterEventControllers               map[string]ClusterEventController
+	clusterRegistrationTokenControllers   map[string]ClusterRegistrationTokenController
+	catalogControllers                    map[string]CatalogController
+	templateControllers                   map[string]TemplateController
+	templateVersionControllers            map[string]TemplateVersionController
+	identityControllers                   map[string]IdentityController
+	tokenControllers                      map[string]TokenController
+	userControllers                       map[string]UserController
+	groupControllers                      map[string]GroupController
+	groupMemberControllers                map[string]GroupMemberController
+	dynamicSchemaControllers              map[string]DynamicSchemaController
 }
 
 func NewForConfig(config rest.Config) (Interface, error) {
@@ -61,12 +81,22 @@ func NewForConfig(config rest.Config) (Interface, error) {
 		machineDriverControllers:              map[string]MachineDriverController{},
 		machineTemplateControllers:            map[string]MachineTemplateController{},
 		projectControllers:                    map[string]ProjectController{},
-		projectRoleTemplateControllers:        map[string]ProjectRoleTemplateController{},
+		roleTemplateControllers:               map[string]RoleTemplateController{},
 		podSecurityPolicyTemplateControllers:  map[string]PodSecurityPolicyTemplateController{},
-		clusterRoleTemplateControllers:        map[string]ClusterRoleTemplateController{},
 		clusterRoleTemplateBindingControllers: map[string]ClusterRoleTemplateBindingController{},
 		projectRoleTemplateBindingControllers: map[string]ProjectRoleTemplateBindingController{},
 		clusterControllers:                    map[string]ClusterController{},
+		clusterEventControllers:               map[string]ClusterEventController{},
+		clusterRegistrationTokenControllers:   map[string]ClusterRegistrationTokenController{},
+		catalogControllers:                    map[string]CatalogController{},
+		templateControllers:                   map[string]TemplateController{},
+		templateVersionControllers:            map[string]TemplateVersionController{},
+		identityControllers:                   map[string]IdentityController{},
+		tokenControllers:                      map[string]TokenController{},
+		userControllers:                       map[string]UserController{},
+		groupControllers:                      map[string]GroupController{},
+		groupMemberControllers:                map[string]GroupMemberController{},
+		dynamicSchemaControllers:              map[string]DynamicSchemaController{},
 	}, nil
 }
 
@@ -134,13 +164,13 @@ func (c *Client) Projects(namespace string) ProjectInterface {
 	}
 }
 
-type ProjectRoleTemplatesGetter interface {
-	ProjectRoleTemplates(namespace string) ProjectRoleTemplateInterface
+type RoleTemplatesGetter interface {
+	RoleTemplates(namespace string) RoleTemplateInterface
 }
 
-func (c *Client) ProjectRoleTemplates(namespace string) ProjectRoleTemplateInterface {
-	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ProjectRoleTemplateResource, ProjectRoleTemplateGroupVersionKind, projectRoleTemplateFactory{})
-	return &projectRoleTemplateClient{
+func (c *Client) RoleTemplates(namespace string) RoleTemplateInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &RoleTemplateResource, RoleTemplateGroupVersionKind, roleTemplateFactory{})
+	return &roleTemplateClient{
 		ns:           namespace,
 		client:       c,
 		objectClient: objectClient,
@@ -160,19 +190,6 @@ func (c *Client) PodSecurityPolicyTemplates(namespace string) PodSecurityPolicyT
 	}
 }
 
-type ClusterRoleTemplatesGetter interface {
-	ClusterRoleTemplates(namespace string) ClusterRoleTemplateInterface
-}
-
-func (c *Client) ClusterRoleTemplates(namespace string) ClusterRoleTemplateInterface {
-	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterRoleTemplateResource, ClusterRoleTemplateGroupVersionKind, clusterRoleTemplateFactory{})
-	return &clusterRoleTemplateClient{
-		ns:           namespace,
-		client:       c,
-		objectClient: objectClient,
-	}
-}
-
 type ClusterRoleTemplateBindingsGetter interface {
 	ClusterRoleTemplateBindings(namespace string) ClusterRoleTemplateBindingInterface
 }
@@ -211,3 +228,146 @@ func (c *Client) Clusters(namespace string) ClusterInterface {
 		objectClient: objectClient,
 	}
 }
+
+type ClusterEventsGetter interface {
+	ClusterEvents(namespace string) ClusterEventInterface
+}
+
+func (c *Client) ClusterEvents(namespace string) ClusterEventInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterEventResource, ClusterEventGroupVersionKind, clusterEventFactory{})
+	return &clusterEventClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type ClusterRegistrationTokensGetter interface {
+	ClusterRegistrationTokens(namespace string) ClusterRegistrationTokenInterface
+}
+
+func (c *Client) ClusterRegistrationTokens(namespace string) ClusterRegistrationTokenInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterRegistrationTokenResource, ClusterRegistrationTokenGroupVersionKind, clusterRegistrationTokenFactory{})
+	return &clusterRegistrationTokenClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type CatalogsGetter interface {
+	Catalogs(namespace string) CatalogInterface
+}
+
+func (c *Client) Catalogs(namespace string) CatalogInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &CatalogResource, CatalogGroupVersionKind, catalogFactory{})
+	return &catalogClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type TemplatesGetter interface {
+	Templates(namespace string) TemplateInterface
+}
+
+func (c *Client) Templates(namespace string) TemplateInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &TemplateResource, TemplateGroupVersionKind, templateFactory{})
+	return &templateClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type TemplateVersionsGetter interface {
+	TemplateVersions(namespace string) TemplateVersionInterface
+}
+
+func (c *Client) TemplateVersions(namespace string) TemplateVersionInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &TemplateVersionResource, TemplateVersionGroupVersionKind, templateVersionFactory{})
+	return &templateVersionClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type IdentitiesGetter interface {
+	Identities(namespace string) IdentityInterface
+}
+
+func (c *Client) Identities(namespace string) IdentityInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &IdentityResource, IdentityGroupVersionKind, identityFactory{})
+	return &identityClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type TokensGetter interface {
+	Tokens(namespace string) TokenInterface
+}
+
+func (c *Client) Tokens(namespace string) TokenInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &TokenResource, TokenGroupVersionKind, tokenFactory{})
+	return &tokenClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type UsersGetter interface {
+	Users(namespace string) UserInterface
+}
+
+func (c *Client) Users(namespace string) UserInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &UserResource, UserGroupVersionKind, userFactory{})
+	return &userClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type GroupsGetter interface {
+	Groups(namespace string) GroupInterface
+}
+
+func (c *Client) Groups(namespace string) GroupInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &GroupResource, GroupGroupVersionKind, groupFactory{})
+	return &groupClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type GroupMembersGetter interface {
+	GroupMembers(namespace string) GroupMemberInterface
+}
+
+func (c *Client) GroupMembers(namespace string) GroupMemberInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &GroupMemberResource, GroupMemberGroupVersionKind, groupMemberFactory{})
+	return &groupMemberClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}
+
+type DynamicSchemasGetter interface {
+	DynamicSchemas(namespace string) DynamicSchemaInterface
+}
+
+func (c *Client) DynamicSchemas(namespace string) DynamicSchemaInterface {
+	objectClient := clientbase.NewObjectClient(namespace, c.restClient, &DynamicSchemaResource, DynamicSchemaGroupVersionKind, dynamicSchemaFactory{})
+	return &dynamicSchemaClient{
+		ns:           namespace,
+		client:       c,
+		objectClient: objectClient,
+	}
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_controller.go

@@ -74,7 +74,13 @@ func (l *machineLister) List(namespace string, selector labels.Selector) (ret []
 }
 
 func (l *machineLister) Get(namespace, name string) (*Machine, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_driver_controller.go

@@ -74,7 +74,13 @@ func (l *machineDriverLister) List(namespace string, selector labels.Selector) (
 }
 
 func (l *machineDriverLister) Get(namespace, name string) (*MachineDriver, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_driver_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type MachineDriverLifecycle interface {
-	Initialize(obj *MachineDriver) error
-	Remove(obj *MachineDriver) error
-	Updated(obj *MachineDriver) error
+	Create(obj *MachineDriver) (*MachineDriver, error)
+	Remove(obj *MachineDriver) (*MachineDriver, error)
+	Updated(obj *MachineDriver) (*MachineDriver, error)
 }
 
 type machineDriverLifecycleAdapter struct {
 	lifecycle MachineDriverLifecycle
 }
 
-func (w *machineDriverLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*MachineDriver))
+func (w *machineDriverLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*MachineDriver))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineDriverLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*MachineDriver))
+func (w *machineDriverLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*MachineDriver))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineDriverLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*MachineDriver))
+func (w *machineDriverLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*MachineDriver))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewMachineDriverLifecycleAdapter(name string, client MachineDriverInterface, l MachineDriverLifecycle) MachineDriverHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type MachineLifecycle interface {
-	Initialize(obj *Machine) error
-	Remove(obj *Machine) error
-	Updated(obj *Machine) error
+	Create(obj *Machine) (*Machine, error)
+	Remove(obj *Machine) (*Machine, error)
+	Updated(obj *Machine) (*Machine, error)
 }
 
 type machineLifecycleAdapter struct {
 	lifecycle MachineLifecycle
 }
 
-func (w *machineLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*Machine))
+func (w *machineLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*Machine))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*Machine))
+func (w *machineLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*Machine))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*Machine))
+func (w *machineLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*Machine))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewMachineLifecycleAdapter(name string, client MachineInterface, l MachineLifecycle) MachineHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_template_controller.go

@@ -74,7 +74,13 @@ func (l *machineTemplateLister) List(namespace string, selector labels.Selector)
 }
 
 func (l *machineTemplateLister) Get(namespace, name string) (*MachineTemplate, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_machine_template_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type MachineTemplateLifecycle interface {
-	Initialize(obj *MachineTemplate) error
-	Remove(obj *MachineTemplate) error
-	Updated(obj *MachineTemplate) error
+	Create(obj *MachineTemplate) (*MachineTemplate, error)
+	Remove(obj *MachineTemplate) (*MachineTemplate, error)
+	Updated(obj *MachineTemplate) (*MachineTemplate, error)
 }
 
 type machineTemplateLifecycleAdapter struct {
 	lifecycle MachineTemplateLifecycle
 }
 
-func (w *machineTemplateLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*MachineTemplate))
+func (w *machineTemplateLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*MachineTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineTemplateLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*MachineTemplate))
+func (w *machineTemplateLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*MachineTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *machineTemplateLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*MachineTemplate))
+func (w *machineTemplateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*MachineTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewMachineTemplateLifecycleAdapter(name string, client MachineTemplateInterface, l MachineTemplateLifecycle) MachineTemplateHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_controller.go

@@ -74,7 +74,13 @@ func (l *podSecurityPolicyTemplateLister) List(namespace string, selector labels
 }
 
 func (l *podSecurityPolicyTemplateLister) Get(namespace, name string) (*PodSecurityPolicyTemplate, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type PodSecurityPolicyTemplateLifecycle interface {
-	Initialize(obj *PodSecurityPolicyTemplate) error
-	Remove(obj *PodSecurityPolicyTemplate) error
-	Updated(obj *PodSecurityPolicyTemplate) error
+	Create(obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error)
+	Remove(obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error)
+	Updated(obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error)
 }
 
 type podSecurityPolicyTemplateLifecycleAdapter struct {
 	lifecycle PodSecurityPolicyTemplateLifecycle
 }
 
-func (w *podSecurityPolicyTemplateLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*PodSecurityPolicyTemplate))
+func (w *podSecurityPolicyTemplateLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*PodSecurityPolicyTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *podSecurityPolicyTemplateLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*PodSecurityPolicyTemplate))
+func (w *podSecurityPolicyTemplateLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*PodSecurityPolicyTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *podSecurityPolicyTemplateLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*PodSecurityPolicyTemplate))
+func (w *podSecurityPolicyTemplateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*PodSecurityPolicyTemplate))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewPodSecurityPolicyTemplateLifecycleAdapter(name string, client PodSecurityPolicyTemplateInterface, l PodSecurityPolicyTemplateLifecycle) PodSecurityPolicyTemplateHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_controller.go

@@ -74,7 +74,13 @@ func (l *projectLister) List(namespace string, selector labels.Selector) (ret []
 }
 
 func (l *projectLister) Get(namespace, name string) (*Project, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type ProjectLifecycle interface {
-	Initialize(obj *Project) error
-	Remove(obj *Project) error
-	Updated(obj *Project) error
+	Create(obj *Project) (*Project, error)
+	Remove(obj *Project) (*Project, error)
+	Updated(obj *Project) (*Project, error)
 }
 
 type projectLifecycleAdapter struct {
 	lifecycle ProjectLifecycle
 }
 
-func (w *projectLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*Project))
+func (w *projectLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*Project))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *projectLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*Project))
+func (w *projectLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*Project))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *projectLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*Project))
+func (w *projectLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*Project))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewProjectLifecycleAdapter(name string, client ProjectInterface, l ProjectLifecycle) ProjectHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_controller.go

@@ -74,7 +74,13 @@ func (l *projectRoleTemplateBindingLister) List(namespace string, selector label
 }
 
 func (l *projectRoleTemplateBindingLister) Get(namespace, name string) (*ProjectRoleTemplateBinding, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
+	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
 	}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_lifecycle_adapter.go

@@ -6,25 +6,37 @@ import (
 )
 
 type ProjectRoleTemplateBindingLifecycle interface {
-	Initialize(obj *ProjectRoleTemplateBinding) error
-	Remove(obj *ProjectRoleTemplateBinding) error
-	Updated(obj *ProjectRoleTemplateBinding) error
+	Create(obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error)
+	Remove(obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error)
+	Updated(obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error)
 }
 
 type projectRoleTemplateBindingLifecycleAdapter struct {
 	lifecycle ProjectRoleTemplateBindingLifecycle
 }
 
-func (w *projectRoleTemplateBindingLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*ProjectRoleTemplateBinding))
+func (w *projectRoleTemplateBindingLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*ProjectRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *projectRoleTemplateBindingLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*ProjectRoleTemplateBinding))
+func (w *projectRoleTemplateBindingLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*ProjectRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
-func (w *projectRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*ProjectRoleTemplateBinding))
+func (w *projectRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*ProjectRoleTemplateBinding))
+	if o == nil {
+		return nil, err
+	}
+	return o, err
 }
 
 func NewProjectRoleTemplateBindingLifecycleAdapter(name string, client ProjectRoleTemplateBindingInterface, l ProjectRoleTemplateBindingLifecycle) ProjectRoleTemplateBindingHandlerFunc {

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_role_template_controller.go

@@ -1,187 +0,0 @@
-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 (
-	ProjectRoleTemplateGroupVersionKind = schema.GroupVersionKind{
-		Version: "v3",
-		Group:   "management.cattle.io",
-		Kind:    "ProjectRoleTemplate",
-	}
-	ProjectRoleTemplateResource = metav1.APIResource{
-		Name:         "projectroletemplates",
-		SingularName: "projectroletemplate",
-		Namespaced:   false,
-		Kind:         ProjectRoleTemplateGroupVersionKind.Kind,
-	}
-)
-
-type ProjectRoleTemplateList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []ProjectRoleTemplate
-}
-
-type ProjectRoleTemplateHandlerFunc func(key string, obj *ProjectRoleTemplate) error
-
-type ProjectRoleTemplateLister interface {
-	List(namespace string, selector labels.Selector) (ret []*ProjectRoleTemplate, err error)
-	Get(namespace, name string) (*ProjectRoleTemplate, error)
-}
-
-type ProjectRoleTemplateController interface {
-	Informer() cache.SharedIndexInformer
-	Lister() ProjectRoleTemplateLister
-	AddHandler(handler ProjectRoleTemplateHandlerFunc)
-	Enqueue(namespace, name string)
-	Sync(ctx context.Context) error
-	Start(ctx context.Context, threadiness int) error
-}
-
-type ProjectRoleTemplateInterface interface {
-	ObjectClient() *clientbase.ObjectClient
-	Create(*ProjectRoleTemplate) (*ProjectRoleTemplate, error)
-	Get(name string, opts metav1.GetOptions) (*ProjectRoleTemplate, error)
-	Update(*ProjectRoleTemplate) (*ProjectRoleTemplate, error)
-	Delete(name string, options *metav1.DeleteOptions) error
-	List(opts metav1.ListOptions) (*ProjectRoleTemplateList, error)
-	Watch(opts metav1.ListOptions) (watch.Interface, error)
-	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Controller() ProjectRoleTemplateController
-}
-
-type projectRoleTemplateLister struct {
-	controller *projectRoleTemplateController
-}
-
-func (l *projectRoleTemplateLister) List(namespace string, selector labels.Selector) (ret []*ProjectRoleTemplate, err error) {
-	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
-		ret = append(ret, obj.(*ProjectRoleTemplate))
-	})
-	return
-}
-
-func (l *projectRoleTemplateLister) Get(namespace, name string) (*ProjectRoleTemplate, error) {
-	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(schema.GroupResource{
-			Group:    ProjectRoleTemplateGroupVersionKind.Group,
-			Resource: "projectRoleTemplate",
-		}, name)
-	}
-	return obj.(*ProjectRoleTemplate), nil
-}
-
-type projectRoleTemplateController struct {
-	controller.GenericController
-}
-
-func (c *projectRoleTemplateController) Lister() ProjectRoleTemplateLister {
-	return &projectRoleTemplateLister{
-		controller: c,
-	}
-}
-
-func (c *projectRoleTemplateController) AddHandler(handler ProjectRoleTemplateHandlerFunc) {
-	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.(*ProjectRoleTemplate))
-	})
-}
-
-type projectRoleTemplateFactory struct {
-}
-
-func (c projectRoleTemplateFactory) Object() runtime.Object {
-	return &ProjectRoleTemplate{}
-}
-
-func (c projectRoleTemplateFactory) List() runtime.Object {
-	return &ProjectRoleTemplateList{}
-}
-
-func (s *projectRoleTemplateClient) Controller() ProjectRoleTemplateController {
-	s.client.Lock()
-	defer s.client.Unlock()
-
-	c, ok := s.client.projectRoleTemplateControllers[s.ns]
-	if ok {
-		return c
-	}
-
-	genericController := controller.NewGenericController(ProjectRoleTemplateGroupVersionKind.Kind+"Controller",
-		s.objectClient)
-
-	c = &projectRoleTemplateController{
-		GenericController: genericController,
-	}
-
-	s.client.projectRoleTemplateControllers[s.ns] = c
-	s.client.starters = append(s.client.starters, c)
-
-	return c
-}
-
-type projectRoleTemplateClient struct {
-	client       *Client
-	ns           string
-	objectClient *clientbase.ObjectClient
-	controller   ProjectRoleTemplateController
-}
-
-func (s *projectRoleTemplateClient) ObjectClient() *clientbase.ObjectClient {
-	return s.objectClient
-}
-
-func (s *projectRoleTemplateClient) Create(o *ProjectRoleTemplate) (*ProjectRoleTemplate, error) {
-	obj, err := s.objectClient.Create(o)
-	return obj.(*ProjectRoleTemplate), err
-}
-
-func (s *projectRoleTemplateClient) Get(name string, opts metav1.GetOptions) (*ProjectRoleTemplate, error) {
-	obj, err := s.objectClient.Get(name, opts)
-	return obj.(*ProjectRoleTemplate), err
-}
-
-func (s *projectRoleTemplateClient) Update(o *ProjectRoleTemplate) (*ProjectRoleTemplate, error) {
-	obj, err := s.objectClient.Update(o.Name, o)
-	return obj.(*ProjectRoleTemplate), err
-}
-
-func (s *projectRoleTemplateClient) Delete(name string, options *metav1.DeleteOptions) error {
-	return s.objectClient.Delete(name, options)
-}
-
-func (s *projectRoleTemplateClient) List(opts metav1.ListOptions) (*ProjectRoleTemplateList, error) {
-	obj, err := s.objectClient.List(opts)
-	return obj.(*ProjectRoleTemplateList), err
-}
-
-func (s *projectRoleTemplateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
-	return s.objectClient.Watch(opts)
-}
-
-func (s *projectRoleTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
-}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_project_role_template_lifecycle_adapter.go

@@ -1,39 +0,0 @@
-package v3
-
-import (
-	"github.com/rancher/norman/lifecycle"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-type ProjectRoleTemplateLifecycle interface {
-	Initialize(obj *ProjectRoleTemplate) error
-	Remove(obj *ProjectRoleTemplate) error
-	Updated(obj *ProjectRoleTemplate) error
-}
-
-type projectRoleTemplateLifecycleAdapter struct {
-	lifecycle ProjectRoleTemplateLifecycle
-}
-
-func (w *projectRoleTemplateLifecycleAdapter) Initialize(obj runtime.Object) error {
-	return w.lifecycle.Initialize(obj.(*ProjectRoleTemplate))
-}
-
-func (w *projectRoleTemplateLifecycleAdapter) Finalize(obj runtime.Object) error {
-	return w.lifecycle.Remove(obj.(*ProjectRoleTemplate))
-}
-
-func (w *projectRoleTemplateLifecycleAdapter) Updated(obj runtime.Object) error {
-	return w.lifecycle.Updated(obj.(*ProjectRoleTemplate))
-}
-
-func NewProjectRoleTemplateLifecycleAdapter(name string, client ProjectRoleTemplateInterface, l ProjectRoleTemplateLifecycle) ProjectRoleTemplateHandlerFunc {
-	adapter := &projectRoleTemplateLifecycleAdapter{lifecycle: l}
-	syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient())
-	return func(key string, obj *ProjectRoleTemplate) error {
-		if obj == nil {
-			return syncFn(key, nil)
-		}
-		return syncFn(key, obj)
-	}
-}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_role_template_controller.go

@@ -0,0 +1,193 @@
+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 (
+	RoleTemplateGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "RoleTemplate",
+	}
+	RoleTemplateResource = metav1.APIResource{
+		Name:         "roletemplates",
+		SingularName: "roletemplate",
+		Namespaced:   false,
+		Kind:         RoleTemplateGroupVersionKind.Kind,
+	}
+)
+
+type RoleTemplateList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []RoleTemplate
+}
+
+type RoleTemplateHandlerFunc func(key string, obj *RoleTemplate) error
+
+type RoleTemplateLister interface {
+	List(namespace string, selector labels.Selector) (ret []*RoleTemplate, err error)
+	Get(namespace, name string) (*RoleTemplate, error)
+}
+
+type RoleTemplateController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() RoleTemplateLister
+	AddHandler(handler RoleTemplateHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type RoleTemplateInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*RoleTemplate) (*RoleTemplate, error)
+	Get(name string, opts metav1.GetOptions) (*RoleTemplate, error)
+	Update(*RoleTemplate) (*RoleTemplate, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*RoleTemplateList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() RoleTemplateController
+}
+
+type roleTemplateLister struct {
+	controller *roleTemplateController
+}
+
+func (l *roleTemplateLister) List(namespace string, selector labels.Selector) (ret []*RoleTemplate, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*RoleTemplate))
+	})
+	return
+}
+
+func (l *roleTemplateLister) Get(namespace, name string) (*RoleTemplate, 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:    RoleTemplateGroupVersionKind.Group,
+			Resource: "roleTemplate",
+		}, name)
+	}
+	return obj.(*RoleTemplate), nil
+}
+
+type roleTemplateController struct {
+	controller.GenericController
+}
+
+func (c *roleTemplateController) Lister() RoleTemplateLister {
+	return &roleTemplateLister{
+		controller: c,
+	}
+}
+
+func (c *roleTemplateController) AddHandler(handler RoleTemplateHandlerFunc) {
+	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.(*RoleTemplate))
+	})
+}
+
+type roleTemplateFactory struct {
+}
+
+func (c roleTemplateFactory) Object() runtime.Object {
+	return &RoleTemplate{}
+}
+
+func (c roleTemplateFactory) List() runtime.Object {
+	return &RoleTemplateList{}
+}
+
+func (s *roleTemplateClient) Controller() RoleTemplateController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.roleTemplateControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(RoleTemplateGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &roleTemplateController{
+		GenericController: genericController,
+	}
+
+	s.client.roleTemplateControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type roleTemplateClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   RoleTemplateController
+}
+
+func (s *roleTemplateClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *roleTemplateClient) Create(o *RoleTemplate) (*RoleTemplate, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*RoleTemplate), err
+}
+
+func (s *roleTemplateClient) Get(name string, opts metav1.GetOptions) (*RoleTemplate, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*RoleTemplate), err
+}
+
+func (s *roleTemplateClient) Update(o *RoleTemplate) (*RoleTemplate, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*RoleTemplate), err
+}
+
+func (s *roleTemplateClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *roleTemplateClient) List(opts metav1.ListOptions) (*RoleTemplateList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*RoleTemplateList), err
+}
+
+func (s *roleTemplateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *roleTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_role_template_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_template_controller.go

@@ -0,0 +1,193 @@
+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 (
+	TemplateGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "Template",
+	}
+	TemplateResource = metav1.APIResource{
+		Name:         "templates",
+		SingularName: "template",
+		Namespaced:   false,
+		Kind:         TemplateGroupVersionKind.Kind,
+	}
+)
+
+type TemplateList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Template
+}
+
+type TemplateHandlerFunc func(key string, obj *Template) error
+
+type TemplateLister interface {
+	List(namespace string, selector labels.Selector) (ret []*Template, err error)
+	Get(namespace, name string) (*Template, error)
+}
+
+type TemplateController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() TemplateLister
+	AddHandler(handler TemplateHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type TemplateInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*Template) (*Template, error)
+	Get(name string, opts metav1.GetOptions) (*Template, error)
+	Update(*Template) (*Template, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*TemplateList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() TemplateController
+}
+
+type templateLister struct {
+	controller *templateController
+}
+
+func (l *templateLister) List(namespace string, selector labels.Selector) (ret []*Template, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*Template))
+	})
+	return
+}
+
+func (l *templateLister) Get(namespace, name string) (*Template, 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:    TemplateGroupVersionKind.Group,
+			Resource: "template",
+		}, name)
+	}
+	return obj.(*Template), nil
+}
+
+type templateController struct {
+	controller.GenericController
+}
+
+func (c *templateController) Lister() TemplateLister {
+	return &templateLister{
+		controller: c,
+	}
+}
+
+func (c *templateController) AddHandler(handler TemplateHandlerFunc) {
+	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.(*Template))
+	})
+}
+
+type templateFactory struct {
+}
+
+func (c templateFactory) Object() runtime.Object {
+	return &Template{}
+}
+
+func (c templateFactory) List() runtime.Object {
+	return &TemplateList{}
+}
+
+func (s *templateClient) Controller() TemplateController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.templateControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(TemplateGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &templateController{
+		GenericController: genericController,
+	}
+
+	s.client.templateControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type templateClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   TemplateController
+}
+
+func (s *templateClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *templateClient) Create(o *Template) (*Template, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*Template), err
+}
+
+func (s *templateClient) Get(name string, opts metav1.GetOptions) (*Template, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*Template), err
+}
+
+func (s *templateClient) Update(o *Template) (*Template, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*Template), err
+}
+
+func (s *templateClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *templateClient) List(opts metav1.ListOptions) (*TemplateList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*TemplateList), err
+}
+
+func (s *templateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *templateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_template_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_template_version_controller.go

@@ -0,0 +1,193 @@
+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 (
+	TemplateVersionGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "TemplateVersion",
+	}
+	TemplateVersionResource = metav1.APIResource{
+		Name:         "templateversions",
+		SingularName: "templateversion",
+		Namespaced:   false,
+		Kind:         TemplateVersionGroupVersionKind.Kind,
+	}
+)
+
+type TemplateVersionList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []TemplateVersion
+}
+
+type TemplateVersionHandlerFunc func(key string, obj *TemplateVersion) error
+
+type TemplateVersionLister interface {
+	List(namespace string, selector labels.Selector) (ret []*TemplateVersion, err error)
+	Get(namespace, name string) (*TemplateVersion, error)
+}
+
+type TemplateVersionController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() TemplateVersionLister
+	AddHandler(handler TemplateVersionHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type TemplateVersionInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*TemplateVersion) (*TemplateVersion, error)
+	Get(name string, opts metav1.GetOptions) (*TemplateVersion, error)
+	Update(*TemplateVersion) (*TemplateVersion, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*TemplateVersionList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() TemplateVersionController
+}
+
+type templateVersionLister struct {
+	controller *templateVersionController
+}
+
+func (l *templateVersionLister) List(namespace string, selector labels.Selector) (ret []*TemplateVersion, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*TemplateVersion))
+	})
+	return
+}
+
+func (l *templateVersionLister) Get(namespace, name string) (*TemplateVersion, 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:    TemplateVersionGroupVersionKind.Group,
+			Resource: "templateVersion",
+		}, name)
+	}
+	return obj.(*TemplateVersion), nil
+}
+
+type templateVersionController struct {
+	controller.GenericController
+}
+
+func (c *templateVersionController) Lister() TemplateVersionLister {
+	return &templateVersionLister{
+		controller: c,
+	}
+}
+
+func (c *templateVersionController) AddHandler(handler TemplateVersionHandlerFunc) {
+	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.(*TemplateVersion))
+	})
+}
+
+type templateVersionFactory struct {
+}
+
+func (c templateVersionFactory) Object() runtime.Object {
+	return &TemplateVersion{}
+}
+
+func (c templateVersionFactory) List() runtime.Object {
+	return &TemplateVersionList{}
+}
+
+func (s *templateVersionClient) Controller() TemplateVersionController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.templateVersionControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(TemplateVersionGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &templateVersionController{
+		GenericController: genericController,
+	}
+
+	s.client.templateVersionControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type templateVersionClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   TemplateVersionController
+}
+
+func (s *templateVersionClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *templateVersionClient) Create(o *TemplateVersion) (*TemplateVersion, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*TemplateVersion), err
+}
+
+func (s *templateVersionClient) Get(name string, opts metav1.GetOptions) (*TemplateVersion, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*TemplateVersion), err
+}
+
+func (s *templateVersionClient) Update(o *TemplateVersion) (*TemplateVersion, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*TemplateVersion), err
+}
+
+func (s *templateVersionClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *templateVersionClient) List(opts metav1.ListOptions) (*TemplateVersionList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*TemplateVersionList), err
+}
+
+func (s *templateVersionClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *templateVersionClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_template_version_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_token_controller.go

@@ -0,0 +1,193 @@
+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 (
+	TokenGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "Token",
+	}
+	TokenResource = metav1.APIResource{
+		Name:         "tokens",
+		SingularName: "token",
+		Namespaced:   false,
+		Kind:         TokenGroupVersionKind.Kind,
+	}
+)
+
+type TokenList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Token
+}
+
+type TokenHandlerFunc func(key string, obj *Token) error
+
+type TokenLister interface {
+	List(namespace string, selector labels.Selector) (ret []*Token, err error)
+	Get(namespace, name string) (*Token, error)
+}
+
+type TokenController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() TokenLister
+	AddHandler(handler TokenHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type TokenInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*Token) (*Token, error)
+	Get(name string, opts metav1.GetOptions) (*Token, error)
+	Update(*Token) (*Token, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*TokenList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() TokenController
+}
+
+type tokenLister struct {
+	controller *tokenController
+}
+
+func (l *tokenLister) List(namespace string, selector labels.Selector) (ret []*Token, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*Token))
+	})
+	return
+}
+
+func (l *tokenLister) Get(namespace, name string) (*Token, 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:    TokenGroupVersionKind.Group,
+			Resource: "token",
+		}, name)
+	}
+	return obj.(*Token), nil
+}
+
+type tokenController struct {
+	controller.GenericController
+}
+
+func (c *tokenController) Lister() TokenLister {
+	return &tokenLister{
+		controller: c,
+	}
+}
+
+func (c *tokenController) AddHandler(handler TokenHandlerFunc) {
+	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.(*Token))
+	})
+}
+
+type tokenFactory struct {
+}
+
+func (c tokenFactory) Object() runtime.Object {
+	return &Token{}
+}
+
+func (c tokenFactory) List() runtime.Object {
+	return &TokenList{}
+}
+
+func (s *tokenClient) Controller() TokenController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.tokenControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(TokenGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &tokenController{
+		GenericController: genericController,
+	}
+
+	s.client.tokenControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type tokenClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   TokenController
+}
+
+func (s *tokenClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *tokenClient) Create(o *Token) (*Token, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*Token), err
+}
+
+func (s *tokenClient) Get(name string, opts metav1.GetOptions) (*Token, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*Token), err
+}
+
+func (s *tokenClient) Update(o *Token) (*Token, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*Token), err
+}
+
+func (s *tokenClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *tokenClient) List(opts metav1.ListOptions) (*TokenList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*TokenList), err
+}
+
+func (s *tokenClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *tokenClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_token_lifecycle_adapter.go

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

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_user_controller.go

@@ -0,0 +1,193 @@
+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 (
+	UserGroupVersionKind = schema.GroupVersionKind{
+		Version: "v3",
+		Group:   "management.cattle.io",
+		Kind:    "User",
+	}
+	UserResource = metav1.APIResource{
+		Name:         "users",
+		SingularName: "user",
+		Namespaced:   false,
+		Kind:         UserGroupVersionKind.Kind,
+	}
+)
+
+type UserList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []User
+}
+
+type UserHandlerFunc func(key string, obj *User) error
+
+type UserLister interface {
+	List(namespace string, selector labels.Selector) (ret []*User, err error)
+	Get(namespace, name string) (*User, error)
+}
+
+type UserController interface {
+	Informer() cache.SharedIndexInformer
+	Lister() UserLister
+	AddHandler(handler UserHandlerFunc)
+	Enqueue(namespace, name string)
+	Sync(ctx context.Context) error
+	Start(ctx context.Context, threadiness int) error
+}
+
+type UserInterface interface {
+	ObjectClient() *clientbase.ObjectClient
+	Create(*User) (*User, error)
+	Get(name string, opts metav1.GetOptions) (*User, error)
+	Update(*User) (*User, error)
+	Delete(name string, options *metav1.DeleteOptions) error
+	List(opts metav1.ListOptions) (*UserList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
+	Controller() UserController
+}
+
+type userLister struct {
+	controller *userController
+}
+
+func (l *userLister) List(namespace string, selector labels.Selector) (ret []*User, err error) {
+	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
+		ret = append(ret, obj.(*User))
+	})
+	return
+}
+
+func (l *userLister) Get(namespace, name string) (*User, 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:    UserGroupVersionKind.Group,
+			Resource: "user",
+		}, name)
+	}
+	return obj.(*User), nil
+}
+
+type userController struct {
+	controller.GenericController
+}
+
+func (c *userController) Lister() UserLister {
+	return &userLister{
+		controller: c,
+	}
+}
+
+func (c *userController) AddHandler(handler UserHandlerFunc) {
+	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.(*User))
+	})
+}
+
+type userFactory struct {
+}
+
+func (c userFactory) Object() runtime.Object {
+	return &User{}
+}
+
+func (c userFactory) List() runtime.Object {
+	return &UserList{}
+}
+
+func (s *userClient) Controller() UserController {
+	s.client.Lock()
+	defer s.client.Unlock()
+
+	c, ok := s.client.userControllers[s.ns]
+	if ok {
+		return c
+	}
+
+	genericController := controller.NewGenericController(UserGroupVersionKind.Kind+"Controller",
+		s.objectClient)
+
+	c = &userController{
+		GenericController: genericController,
+	}
+
+	s.client.userControllers[s.ns] = c
+	s.client.starters = append(s.client.starters, c)
+
+	return c
+}
+
+type userClient struct {
+	client       *Client
+	ns           string
+	objectClient *clientbase.ObjectClient
+	controller   UserController
+}
+
+func (s *userClient) ObjectClient() *clientbase.ObjectClient {
+	return s.objectClient
+}
+
+func (s *userClient) Create(o *User) (*User, error) {
+	obj, err := s.objectClient.Create(o)
+	return obj.(*User), err
+}
+
+func (s *userClient) Get(name string, opts metav1.GetOptions) (*User, error) {
+	obj, err := s.objectClient.Get(name, opts)
+	return obj.(*User), err
+}
+
+func (s *userClient) Update(o *User) (*User, error) {
+	obj, err := s.objectClient.Update(o.Name, o)
+	return obj.(*User), err
+}
+
+func (s *userClient) Delete(name string, options *metav1.DeleteOptions) error {
+	return s.objectClient.Delete(name, options)
+}
+
+func (s *userClient) List(opts metav1.ListOptions) (*UserList, error) {
+	obj, err := s.objectClient.List(opts)
+	return obj.(*UserList), err
+}
+
+func (s *userClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return s.objectClient.Watch(opts)
+}
+
+func (s *userClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
+}

vendor/github.com/rancher/types/apis/management.cattle.io/v3/zz_generated_user_lifecycle_adapter.go

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

vendor/github.com/rancher/types/vendor.conf

@@ -3,5 +3,5 @@ github.com/rancher/types
 
 k8s.io/kubernetes v1.8.3 transitive=true,staging=true
 bitbucket.org/ww/goautoneg a547fc61f48d567d5b4ec6f8aee5573d8efce11d https://github.com/rancher/goautoneg.git
-github.com/rancher/norman 18d3f69aa84ed39326e731ebfa509cf104bf9ad1 transitive=true
+github.com/rancher/norman 8c0d4bfe2e63a801e4e21906d6b37a5173dadcbb
 golang.org/x/sync fd80eb99c8f653c847d294a001bdf2a3a6f768f5