controllergen.Run(args.Options{
		OutputPackage: "github.com/rancher/rancher/pkg/generated",
		Boilerplate:   "scripts/boilerplate.go.txt",
		Groups: map[string]args.Group{
			"management.cattle.io": {
				PackageName: "management.cattle.io",
				Types: []interface{}{
					// All structs with an embedded ObjectMeta field will be picked up
					"./pkg/apis/management.cattle.io/v3",
					// ProjectCatalog and ClusterCatalog are named
					// explicitly here because they do not have an
					// ObjectMeta field in their struct. Instead
					// they embed type v3.Catalog{} which
					// is a valid object on its own and is generated
					// above.
					v3.ProjectCatalog{},
					v3.ClusterCatalog{},
				},
				GenerateTypes: true,
			},
			"ui.cattle.io": {
				PackageName: "ui.cattle.io",
				Types: []interface{}{
					"./pkg/apis/ui.cattle.io/v1",
				},
				GenerateTypes: true,
			},
		},
	})

import (
	"github.com/rancher/norman/types"
)

// +genclient
// +genclient:nonNamespaced
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

type Setting struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Value      string `json:"value" norman:"required"`
	Default    string `json:"default" norman:"nocreate,noupdate"`
	Customized bool   `json:"customized" norman:"nocreate,noupdate"`
	Source     string `json:"source" norman:"nocreate,noupdate,options=db|default|env"`
}

// +genclient
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

type ProjectCatalog struct {
	types.Namespaced

	Catalog     `json:",inline" mapstructure:",squash"`
	ProjectName string `json:"projectName,omitempty" norman:"type=reference[project]"`
}

// +genclient
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

type ClusterCatalog struct {
	types.Namespaced

	Catalog     `json:",inline" mapstructure:",squash"`
	ClusterName string `json:"clusterName,omitempty" norman:"required,type=reference[cluster]"`
}

// +genclient
// +genclient:nonNamespaced
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

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 catalog. 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"`
}

import (
	"github.com/rancher/rancher/pkg/generated/controllers/management.cattle.io"
	"k8s.io/client-go/rest"
)

func createFactory(config *rest.Config) {
	mgmt, err := management.NewFactoryFromConfig(restConfig)
	if err != nil {
		return nil, err
	}
}

// Running the functions Management() and V3(), which are the api group and version of the resource types I have generated in this example, is necessary
// to instantiate the controller factories for the group and version. User() instantiates the controller for the user resource. This
// can be done elsewhere, like when creating a struct but it must be done before the controller is run. Otherwise, the cache will
// not work. In this case we are registering a handler so we would have ended up using these methods by necessity, but if we wanted	
// to access a cache for another resource type in our handler then we also need to make sure it is instantiated in a similar fashion.
users := mgmt.Management().V3().User("")

import (
	"context"

	"github.com/rancher/rancher/pkg/generated/controllers/management.cattle.io"
	"github.com/rancher/wrangler/pkg/generated/controllers/core"
	"k8s.io/client-go/rest"
)

mgmt, err := management.NewFactoryFromConfig(restConfig)
if err != nil {
	return nil, err
}

users := mgmt.Management().V3().User("")
// passing a namespace here is optional. If an empty string is passed then the client will look at
// all configmap objects from all namespaces
configmaps := core.Management().Core().Configmaps("examplenamespace")

syncHandler := func(id string, obj *v3.User) (*v3.User, error) {
	if obj != nil {
		return obj, nil
	}

	recordedNote := obj.Annotations != nil && obj.Annotations["wroteanoteaboutuser"] == "true"

	if recordedNote {
		// there already is a note, noop
		return obj, nil
	}

	// we are getting the "mainrecord" configmap from the configmap cache. The cache is maintained
	// locally and can try to fulfill requests without using the k8s api. This is much faster and
	// efficient, however it does not update immediately so it is possible that if the object
	// being requested was recently created that the cache will miss and return a not found error.
	// In this scenario you can either count on the handler reenqueueing and retrying or you can
	// just use the regular client.
	record, err := configmaps.Cache().Get("", "mainrecord")
	if err != nil {
		return obj, err
	}

	record.Data[obj.name] = "recorded"
	record, err = configmaps.Update(record)
	if err != nil {
		return obj, err
	}

	// This is done because obj is from the cache that is iterated over to run handlers and perform other tasks. If the subsequent
	// update fails then we will end up with an object on our cache that does not match the "truth" (how the object is in etcd).
	obj = obj.DeepCopy()

	if obj.Annotations == nil {
		obj.Anotations = make(map[string]string)
	}

	obj.Annotations["wroteanoteaboutuser"] = "true"

	// Here we are using the k8s client embedded onto the users controller to perform an update. This will go to the K8s API.
	return users.Update(obj)
}

users.OnChange(context.Background(), "user-example-annotate-note-handler", syncHandler)

type FooController interface {
	FooClient

	// OnChange registers a handler that will run whenever an object of the matching resource type is created or updated. This function accepts a sync function specifically generated for the object type and then wraps the function in a function that is compatible with AddGenericHandler. It then uses AddGenericHandler to register the wrapped function.
	OnChange(ctx context.Context, name string, sync FooHandler)
	// OnRemove registers a handler that will run whenever an object of the matching resource type is removed. This function accepts a sync function specifically generated for the object type and then wraps the function in a function that is compatible with AddGenericRemoveHandler. It then uses AddGenericRemoveHandler to register the wrapped function.
	OnRemove(ctx context.Context, name string, sync FooHandler)
	// Enqueue will rerun all handlers registered to the object's type against the object
	Enqueue(namespace, name string)

	// Cache returns a locally maintained cache that can be used for get and list requests
	Cache() FooCache

	// Informer returns an informer for the resource type
	Informer() cache.SharedIndexInformer
	// GroupVersionKind returns the API group, version, and Kind of the resource type the controller is for
	GroupVersionKind() schema.GroupVersionKind

	// AddGenericHandler registers the handler function for the controller
	AddGenericHandler(ctx context.Context, name string, handler generic.Handler)
	// AddGenericRemoveHandler registers a handler that will happen when an object of the controller's resource type is removed
	AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler)
	// Updater returns a function that accepts a runtime.Object and asserts it as the controller's respective resource type struct. It then passes the object to the resource type's client's update function. This is mainly consumed internally by wrangler to implement other functionality.
	Updater() generic.Updater
}

type FooClient interface {
	// Create creates a new instance of resource type in kubernetes
	Create(*v1alpha1.Foo) (*v1alpha1.Foo, error)
	// Update updates the given object in kubernetes
	Update(*v1alpha1.Foo) (*v1alpha1.Foo, error)
	// Status of type's CRD must be a subresource for this method to be generated. Only updates
	// status and does not trigger OnChange handlers.
	UpdateStatus(*v1alpha1.Foo) (*v1alpha1.Foo, error)
	// Delete deletes the given object in kubernetes
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	// Get gets the object of the given name and namespace in kubernetes
	Get(namespace, name string, options metav1.GetOptions) (*v1alpha1.Foo, error)
	// List lists all the objects matching the given namespace for the resource type
	List(namespace string, opts metav1.ListOptions) (*v1alpha1.FooList, error)
	// Watch returns a channel that will stream objects as they are created, removed, or updated
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	// Patch accepts a diff that can be applied to an existing object for the client's resource type. Depending on PatchType, which specifies the strategy
	// to be used when applying the diff, patch can also create a new object. See the following for more information: https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/, https://kubernetes.io/docs/reference/using-api/server-side-apply/.
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Foo, err error)
}

type FooCache interface {
	// Get gets the object of the given name and namespace from the local cache
	Get(namespace, name string) (*v1alpha1.Foo, error)
	// List lists all the objects matching the given namespace for the resource type from the cache
	List(namespace string, selector labels.Selector) ([]*v1alpha1.Foo, error)

	// AddIndexer is used to register a function will be used to organize objects in the cache. The indexer will return a string which indicates something about the object.
	AddIndexer(indexName string, indexer FooIndexer)
	// GetByIndex will search for objects that match the given key when the named indexer is applied to it
	GetByIndex(indexName, key string) ([]*v1alpha1.Foo, error)
}

type FooIndexer func(obj *v1alpha1.Foo) ([]string, error)