diff --git a/api/builtin/api_root.go b/api/builtin/api_root.go
new file mode 100644
index 000000000..7ff1b366d
--- /dev/null
+++ b/api/builtin/api_root.go
@@ -0,0 +1,123 @@
+package builtin
+
+import (
+	"github.com/rancher/norman/store/empty"
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+func APIRootFormatter(apiContext *types.APIContext, resource *types.RawResource) {
+	path, _ := resource.Values["path"].(string)
+	if path == "" {
+		return
+	}
+
+	delete(resource.Values, "path")
+
+	resource.Links["root"] = apiContext.URLBuilder.RelativeToRoot(path)
+
+	data, _ := resource.Values["apiVersion"].(map[string]interface{})
+	apiVersion := apiVersionFromMap(apiContext.Schemas, data)
+
+	resource.Links["self"] = apiContext.URLBuilder.Version(apiVersion)
+
+	if len(apiVersion.SubContexts) > 0 {
+		subContextToSchema := apiContext.Schemas.SubContextSchemas()
+		if len(subContextToSchema) > 0 {
+			for _, schema := range subContextToSchema {
+				addCollectionLink(apiContext, schema, resource.Links)
+			}
+
+			for _, schema := range getNonReferencedSchemas(apiContext.Schemas.SchemasForVersion(apiVersion),
+				subContextToSchema) {
+				addCollectionLink(apiContext, schema, resource.Links)
+			}
+
+			return
+		}
+	}
+
+	for _, schema := range apiContext.Schemas.SchemasForVersion(apiVersion) {
+		addCollectionLink(apiContext, schema, resource.Links)
+	}
+
+	return
+}
+
+func getNonReferencedSchemas(schemas map[string]*types.Schema, subContexts map[string]*types.Schema) []*types.Schema {
+	var result []*types.Schema
+	typeNames := map[string]bool{}
+
+	for _, subContext := range subContexts {
+		ref := convert.ToReference(subContext.ID)
+		fullRef := convert.ToFullReference(subContext.Version.Path, subContext.ID)
+		typeNames[ref] = true
+		typeNames[fullRef] = true
+	}
+
+outer:
+	for _, schema := range schemas {
+		for _, field := range schema.ResourceFields {
+			if typeNames[field.Type] {
+				continue outer
+			}
+		}
+
+		result = append(result, schema)
+	}
+
+	return result
+}
+
+func addCollectionLink(apiContext *types.APIContext, schema *types.Schema, links map[string]string) {
+	collectionLink := getSchemaCollectionLink(apiContext, schema, nil)
+	if collectionLink != "" {
+		links[schema.PluralName] = collectionLink
+	}
+}
+
+type APIRootStore struct {
+	empty.Store
+	roots []string
+}
+
+func NewAPIRootStore(roots []string) types.Store {
+	return &APIRootStore{roots: roots}
+}
+
+func (a *APIRootStore) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
+	for _, version := range apiContext.Schemas.Versions() {
+		if version.Path == id {
+			return apiVersionToAPIRootMap(version), nil
+		}
+	}
+	return nil, nil
+}
+
+func (a *APIRootStore) List(apiContext *types.APIContext, schema *types.Schema, opt types.QueryOptions) ([]map[string]interface{}, error) {
+	var roots []map[string]interface{}
+
+	for _, version := range apiContext.Schemas.Versions() {
+		roots = append(roots, apiVersionToAPIRootMap(version))
+	}
+
+	for _, root := range a.roots {
+		roots = append(roots, map[string]interface{}{
+			"path": root,
+		})
+	}
+
+	return roots, nil
+}
+
+func apiVersionToAPIRootMap(version types.APIVersion) map[string]interface{} {
+	return map[string]interface{}{
+		"type": "/v1-meta/schemas/apiRoot",
+		"apiVersion": map[string]interface{}{
+			"version": version.Version,
+			"group":   version.Group,
+			"path":    version.Path,
+		},
+		"path": version.Path,
+	}
+}
diff --git a/api/builtin/builtin.go b/api/builtin/schema.go
similarity index 53%
rename from api/builtin/builtin.go
rename to api/builtin/schema.go
index b3cfe3d25..10bc37fb0 100644
--- a/api/builtin/builtin.go
+++ b/api/builtin/schema.go
@@ -3,16 +3,15 @@ package builtin
 import (
 	"net/http"
 
-	"github.com/rancher/norman/store/empty"
 	"github.com/rancher/norman/store/schema"
 	"github.com/rancher/norman/types"
 )
 
 var (
 	Version = types.APIVersion{
-		Group:   "io.cattle.builtin",
-		Version: "v3",
-		Path:    "/v3",
+		Group:   "meta.cattle.io",
+		Version: "v1",
+		Path:    "/v1-meta",
 	}
 
 	Schema = types.Schema{
@@ -23,7 +22,7 @@ var (
 		ResourceFields: map[string]types.Field{
 			"collectionActions": {Type: "map[json]"},
 			"collectionFields":  {Type: "map[json]"},
-			"collectionFitlers": {Type: "map[json]"},
+			"collectionFilters": {Type: "map[json]"},
 			"collectionMethods": {Type: "array[string]"},
 			"pluralName":        {Type: "string"},
 			"resourceActions":   {Type: "map[json]"},
@@ -41,10 +40,11 @@ var (
 		ResourceMethods:   []string{},
 		CollectionMethods: []string{},
 		ResourceFields: map[string]types.Field{
-			"code":    {Type: "string"},
-			"detail":  {Type: "string"},
-			"message": {Type: "string"},
-			"status":  {Type: "int"},
+			"code":      {Type: "string"},
+			"detail":    {Type: "string", Nullable: true},
+			"message":   {Type: "string", Nullable: true},
+			"fieldName": {Type: "string", Nullable: true},
+			"status":    {Type: "int"},
 		},
 	}
 
@@ -81,32 +81,46 @@ var (
 		AddSchema(&APIRoot)
 )
 
-func apiVersionFromMap(apiVersion map[string]interface{}) types.APIVersion {
+func apiVersionFromMap(schemas *types.Schemas, apiVersion map[string]interface{}) types.APIVersion {
 	path, _ := apiVersion["path"].(string)
 	version, _ := apiVersion["version"].(string)
 	group, _ := apiVersion["group"].(string)
 
-	return types.APIVersion{
+	apiVersionObj := types.APIVersion{
 		Path:    path,
 		Version: version,
 		Group:   group,
 	}
+
+	for _, testVersion := range schemas.Versions() {
+		if testVersion.Equals(&apiVersionObj) {
+			return testVersion
+		}
+	}
+
+	return apiVersionObj
 }
 
 func SchemaFormatter(apiContext *types.APIContext, resource *types.RawResource) {
 	data, _ := resource.Values["version"].(map[string]interface{})
-	apiVersion := apiVersionFromMap(data)
+	apiVersion := apiVersionFromMap(apiContext.Schemas, data)
 
 	schema := apiContext.Schemas.Schema(&apiVersion, resource.ID)
-	collectionLink := getSchemaCollectionLink(apiContext, schema)
+	if schema == nil {
+		return
+	}
+
+	collectionLink := getSchemaCollectionLink(apiContext, schema, &apiVersion)
 	if collectionLink != "" {
 		resource.Links["collection"] = collectionLink
 	}
+
+	resource.Links["self"] = apiContext.URLBuilder.SchemaLink(schema)
 }
 
-func getSchemaCollectionLink(apiContext *types.APIContext, schema *types.Schema) string {
+func getSchemaCollectionLink(apiContext *types.APIContext, schema *types.Schema, apiVersion *types.APIVersion) string {
 	if schema != nil && contains(schema.CollectionMethods, http.MethodGet) {
-		return apiContext.URLBuilder.Collection(schema)
+		return apiContext.URLBuilder.Collection(schema, apiVersion)
 	}
 	return ""
 }
@@ -119,68 +133,3 @@ func contains(list []string, needle string) bool {
 	}
 	return false
 }
-
-func APIRootFormatter(apiContext *types.APIContext, resource *types.RawResource) {
-	path, _ := resource.Values["path"].(string)
-	if path == "" {
-		return
-	}
-
-	resource.Links["root"] = apiContext.URLBuilder.RelativeToRoot(path)
-
-	data, _ := resource.Values["apiVersion"].(map[string]interface{})
-	apiVersion := apiVersionFromMap(data)
-
-	for name, schema := range apiContext.Schemas.SchemasForVersion(apiVersion) {
-		collectionLink := getSchemaCollectionLink(apiContext, schema)
-		if collectionLink != "" {
-			resource.Links[name] = collectionLink
-		}
-	}
-}
-
-type APIRootStore struct {
-	empty.Store
-	roots []string
-}
-
-func NewAPIRootStore(roots []string) types.Store {
-	return &APIRootStore{roots: roots}
-}
-
-func (a *APIRootStore) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
-	for _, version := range apiContext.Schemas.Versions() {
-		if version.Path == id {
-			return apiVersionToAPIRootMap(version), nil
-		}
-	}
-	return nil, nil
-}
-
-func (a *APIRootStore) List(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) ([]map[string]interface{}, error) {
-	roots := []map[string]interface{}{}
-
-	for _, version := range apiContext.Schemas.Versions() {
-		roots = append(roots, apiVersionToAPIRootMap(version))
-	}
-
-	for _, root := range a.roots {
-		roots = append(roots, map[string]interface{}{
-			"path": root,
-		})
-	}
-
-	return roots, nil
-}
-
-func apiVersionToAPIRootMap(version types.APIVersion) map[string]interface{} {
-	return map[string]interface{}{
-		"type": "/v3/apiRoot",
-		"apiVersion": map[string]interface{}{
-			"version": version.Version,
-			"group":   version.Group,
-			"path":    version.Path,
-		},
-		"path": version.Path,
-	}
-}
diff --git a/api/formatter/subcontext_filter.go b/api/formatter/subcontext_filter.go
new file mode 100644
index 000000000..1a1c0ee1d
--- /dev/null
+++ b/api/formatter/subcontext_filter.go
@@ -0,0 +1,25 @@
+package formatter
+
+import (
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+func SubContextFormatter(apiContext *types.APIContext, resource *types.RawResource) {
+	if resource.Schema.SubContext == "" {
+		return
+	}
+
+	ref := convert.ToReference(resource.Schema.ID)
+	fullRef := convert.ToFullReference(resource.Schema.Version.Path, resource.Schema.ID)
+
+outer:
+	for _, schema := range apiContext.Schemas.Schemas() {
+		for _, field := range schema.ResourceFields {
+			if (field.Type == ref || field.Type == fullRef) && schema.Version.SubContexts[resource.Schema.SubContext] {
+				resource.Links[schema.PluralName] = apiContext.URLBuilder.SubContextCollection(resource.Schema, resource.ID, schema)
+				continue outer
+			}
+		}
+	}
+}
diff --git a/api/handler/create.go b/api/handler/create.go
new file mode 100644
index 000000000..8f3f1249d
--- /dev/null
+++ b/api/handler/create.go
@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/rancher/norman/types"
+)
+
+func CreateHandler(apiContext *types.APIContext) error {
+	var err error
+
+	data, err := ParseAndValidateBody(apiContext)
+	if err != nil {
+		return err
+	}
+
+	store := apiContext.Schema.Store
+	if store != nil {
+		data, err = store.Create(apiContext, apiContext.Schema, data)
+		if err != nil {
+			return err
+		}
+	}
+
+	apiContext.WriteResponse(http.StatusCreated, data)
+	return nil
+}
diff --git a/api/handlers/delete.go b/api/handler/delete.go
similarity index 94%
rename from api/handlers/delete.go
rename to api/handler/delete.go
index b6718bf27..348ea5e64 100644
--- a/api/handlers/delete.go
+++ b/api/handler/delete.go
@@ -1,4 +1,4 @@
-package handlers
+package handler
 
 import (
 	"net/http"
diff --git a/api/handlers/list.go b/api/handler/list.go
similarity index 76%
rename from api/handlers/list.go
rename to api/handler/list.go
index 714a31059..3f664eefa 100644
--- a/api/handlers/list.go
+++ b/api/handler/list.go
@@ -1,4 +1,4 @@
-package handlers
+package handler
 
 import (
 	"net/http"
@@ -19,8 +19,8 @@ func ListHandler(request *types.APIContext) error {
 	}
 
 	if request.ID == "" {
-		request.QueryOptions = parse.QueryOptions(request.Request, request.Schema)
-		data, err = store.List(request, request.Schema, request.QueryOptions)
+		opts := parse.QueryOptions(request, request.Schema)
+		data, err = store.List(request, request.Schema, opts)
 	} else if request.Link == "" {
 		data, err = store.ByID(request, request.Schema, request.ID)
 	} else {
diff --git a/api/handler/query.go b/api/handler/query.go
new file mode 100644
index 000000000..e199a8838
--- /dev/null
+++ b/api/handler/query.go
@@ -0,0 +1,121 @@
+package handler
+
+import (
+	"sort"
+
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+func QueryFilter(opts types.QueryOptions, data []map[string]interface{}) []map[string]interface{} {
+	return ApplyQueryOptions(opts, data)
+}
+
+func ApplyQueryOptions(options types.QueryOptions, data []map[string]interface{}) []map[string]interface{} {
+	data = ApplyQueryConditions(options.Conditions, data)
+	data = ApplySort(options.Sort, data)
+	return ApplyPagination(options.Pagination, data)
+}
+
+func ApplySort(sortOpts types.Sort, data []map[string]interface{}) []map[string]interface{} {
+	name := sortOpts.Name
+	if name == "" {
+		name = "id"
+	}
+
+	sort.Slice(data, func(i, j int) bool {
+		left, right := i, j
+		if sortOpts.Order == types.DESC {
+			left, right = j, i
+		}
+
+		return convert.ToString(data[left][name]) < convert.ToString(data[right][name])
+	})
+
+	return data
+}
+
+func ApplyQueryConditions(conditions []*types.QueryCondition, data []map[string]interface{}) []map[string]interface{} {
+	var result []map[string]interface{}
+
+outer:
+	for _, item := range data {
+		for _, condition := range conditions {
+			if !condition.Valid(item) {
+				continue outer
+			}
+		}
+
+		result = append(result, item)
+	}
+
+	return result
+}
+
+func ApplyPagination(pagination *types.Pagination, data []map[string]interface{}) []map[string]interface{} {
+	if pagination == nil || pagination.Limit == nil {
+		return data
+	}
+
+	limit := *pagination.Limit
+	if limit < 0 {
+		limit = 0
+	}
+
+	total := int64(len(data))
+
+	// Reset fields
+	pagination.Next = ""
+	pagination.Previous = ""
+	pagination.Partial = false
+	pagination.Total = &total
+	pagination.First = ""
+
+	if len(data) == 0 {
+		return data
+	}
+
+	// startIndex is guaranteed to be a valid index
+	startIndex := int64(0)
+	if pagination.Marker != "" {
+		for i, item := range data {
+			id, _ := item["id"].(string)
+			if id == pagination.Marker {
+				startIndex = int64(i)
+				break
+			}
+		}
+	}
+
+	previousIndex := startIndex - limit
+	if previousIndex <= 0 {
+		previousIndex = 0
+	}
+	nextIndex := startIndex + limit
+	if nextIndex > int64(len(data)) {
+		nextIndex = int64(len(data))
+	}
+
+	if previousIndex < startIndex {
+		pagination.Previous, _ = data[previousIndex]["id"].(string)
+	}
+
+	if nextIndex > startIndex && nextIndex < int64(len(data)) {
+		pagination.Next, _ = data[nextIndex]["id"].(string)
+	}
+
+	if startIndex > 0 || nextIndex < int64(len(data)) {
+		pagination.Partial = true
+	}
+
+	if pagination.Partial {
+		pagination.First, _ = data[0]["id"].(string)
+
+		lastIndex := int64(len(data)) - limit
+		if lastIndex > 0 && lastIndex < int64(len(data)) {
+			pagination.Last, _ = data[lastIndex]["id"].(string)
+		}
+	}
+
+	return data[startIndex:nextIndex]
+}
diff --git a/api/handler/update.go b/api/handler/update.go
new file mode 100644
index 000000000..47e584a31
--- /dev/null
+++ b/api/handler/update.go
@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/rancher/norman/types"
+)
+
+func UpdateHandler(apiContext *types.APIContext) error {
+	data, err := ParseAndValidateBody(apiContext)
+	if err != nil {
+		return err
+	}
+
+	store := apiContext.Schema.Store
+	if store != nil {
+		data, err = store.Update(apiContext, apiContext.Schema, data, apiContext.ID)
+		if err != nil {
+			return err
+		}
+	}
+
+	apiContext.WriteResponse(http.StatusOK, data)
+	return nil
+}
diff --git a/api/handler/validate.go b/api/handler/validate.go
new file mode 100644
index 000000000..c83b87b60
--- /dev/null
+++ b/api/handler/validate.go
@@ -0,0 +1,26 @@
+package handler
+
+import (
+	"github.com/rancher/norman/parse"
+	"github.com/rancher/norman/parse/builder"
+	"github.com/rancher/norman/types"
+)
+
+func ParseAndValidateBody(apiContext *types.APIContext) (map[string]interface{}, error) {
+	data, err := parse.Body(apiContext.Request)
+	if err != nil {
+		return nil, err
+	}
+
+	b := builder.NewBuilder(apiContext)
+
+	data, err = b.Construct(apiContext.Schema, data, builder.Create)
+	validator := apiContext.Schema.Validator
+	if validator != nil {
+		if err := validator(apiContext, data); err != nil {
+			return nil, err
+		}
+	}
+
+	return data, nil
+}
diff --git a/api/handlers/create.go b/api/handlers/create.go
deleted file mode 100644
index 68384d313..000000000
--- a/api/handlers/create.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"github.com/rancher/norman/types"
-)
-
-func CreateHandler(request *types.APIContext) error {
-	var err error
-
-	validator := request.Schema.Validator
-	if validator != nil {
-		if err := validator(request, request.Body); err != nil {
-			return err
-		}
-	}
-
-	data := request.Body
-
-	store := request.Schema.Store
-	if store != nil {
-		data, err = store.Create(request, request.Schema, data)
-		if err != nil {
-			return err
-		}
-	}
-
-	request.WriteResponse(http.StatusCreated, data)
-	return nil
-}
diff --git a/api/handlers/update.go b/api/handlers/update.go
deleted file mode 100644
index 94a5978ec..000000000
--- a/api/handlers/update.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"github.com/rancher/norman/types"
-)
-
-func UpdateHandler(request *types.APIContext) error {
-	var err error
-
-	validator := request.Schema.Validator
-	if validator != nil {
-		if err := validator(request, request.Body); err != nil {
-			return err
-		}
-	}
-
-	data := request.Body
-	store := request.Schema.Store
-	if store != nil {
-		data, err = store.Update(request, request.Schema, data, request.ID)
-		if err != nil {
-			return err
-		}
-	}
-
-	request.WriteResponse(http.StatusOK, data)
-	return nil
-}
diff --git a/api/headers.go b/api/headers.go
index fa253e891..ed49c169c 100644
--- a/api/headers.go
+++ b/api/headers.go
@@ -16,7 +16,7 @@ func addSchemasHeader(apiContext *types.APIContext) error {
 		return nil
 	}
 
-	apiContext.Response.Header().Set("X-Api-Schemas", apiContext.URLBuilder.Collection(schema))
+	apiContext.Response.Header().Set("X-Api-Schemas", apiContext.URLBuilder.Collection(schema, apiContext.Version))
 	return nil
 }
 
diff --git a/api/server.go b/api/server.go
index 909cfdfe1..130e97fb0 100644
--- a/api/server.go
+++ b/api/server.go
@@ -1,27 +1,35 @@
 package api
 
 import (
-	"context"
 	"net/http"
 
+	"sync"
+
 	"github.com/rancher/norman/api/builtin"
-	"github.com/rancher/norman/api/handlers"
+	"github.com/rancher/norman/api/handler"
 	"github.com/rancher/norman/api/writer"
 	"github.com/rancher/norman/authorization"
 	"github.com/rancher/norman/httperror"
 	"github.com/rancher/norman/parse"
-	"github.com/rancher/norman/parse/builder"
+	"github.com/rancher/norman/store/wrapper"
 	"github.com/rancher/norman/types"
 )
 
+type StoreWrapper func(types.Store) types.Store
+
 type Parser func(rw http.ResponseWriter, req *http.Request) (*types.APIContext, error)
 
 type Server struct {
-	IgnoreBuiltin   bool
-	Parser          Parser
-	ResponseWriters map[string]ResponseWriter
-	schemas         *types.Schemas
-	Defaults        Defaults
+	initBuiltin                 sync.Once
+	IgnoreBuiltin               bool
+	Parser                      Parser
+	Resolver                    parse.ResolverFunc
+	SubContextAttributeProvider types.SubContextAttributeProvider
+	ResponseWriters             map[string]ResponseWriter
+	schemas                     *types.Schemas
+	QueryFilter                 types.QueryFilter
+	StoreWrapper                StoreWrapper
+	Defaults                    Defaults
 }
 
 type Defaults struct {
@@ -42,35 +50,44 @@ func NewAPIServer() *Server {
 			"json": &writer.JSONResponseWriter{},
 			"html": &writer.HTMLResponseWriter{},
 		},
+		SubContextAttributeProvider: &parse.DefaultSubContextAttributeProvider{},
+		Resolver:                    parse.DefaultResolver,
 		Defaults: Defaults{
-			CreateHandler: handlers.CreateHandler,
-			DeleteHandler: handlers.DeleteHandler,
-			UpdateHandler: handlers.UpdateHandler,
-			ListHandler:   handlers.ListHandler,
+			CreateHandler: handler.CreateHandler,
+			DeleteHandler: handler.DeleteHandler,
+			UpdateHandler: handler.UpdateHandler,
+			ListHandler:   handler.ListHandler,
 			LinkHandler: func(*types.APIContext) error {
-				return httperror.NewAPIError(httperror.NOT_FOUND, "Link not found")
+				return httperror.NewAPIError(httperror.NotFound, "Link not found")
 			},
 			ErrorHandler: httperror.ErrorHandler,
 		},
+		StoreWrapper: wrapper.Wrap,
+		QueryFilter:  handler.QueryFilter,
 	}
 
-	s.Parser = func(rw http.ResponseWriter, req *http.Request) (*types.APIContext, error) {
-		ctx, err := parse.Parse(rw, req, s.schemas)
-		ctx.ResponseWriter = s.ResponseWriters[ctx.ResponseFormat]
-		if ctx.ResponseWriter == nil {
-			ctx.ResponseWriter = s.ResponseWriters["json"]
-		}
+	s.Parser = s.parser
+	return s
+}
 
-		ctx.AccessControl = &authorization.AllAccess{}
+func (s *Server) parser(rw http.ResponseWriter, req *http.Request) (*types.APIContext, error) {
+	ctx, err := parse.Parse(rw, req, s.schemas, s.Resolver)
+	ctx.ResponseWriter = s.ResponseWriters[ctx.ResponseFormat]
+	if ctx.ResponseWriter == nil {
+		ctx.ResponseWriter = s.ResponseWriters["json"]
+	}
 
-		return ctx, err
+	if ctx.QueryFilter == nil {
+		ctx.QueryFilter = s.QueryFilter
 	}
 
-	return s
-}
+	if ctx.SubContextAttributeProvider == nil {
+		ctx.SubContextAttributeProvider = s.SubContextAttributeProvider
+	}
 
-func (s *Server) Start(ctx context.Context) error {
-	return s.addBuiltins(ctx)
+	ctx.AccessControl = &authorization.AllAccess{}
+
+	return ctx, err
 }
 
 func (s *Server) AddSchemas(schemas *types.Schemas) error {
@@ -78,6 +95,16 @@ func (s *Server) AddSchemas(schemas *types.Schemas) error {
 		return schemas.Err()
 	}
 
+	s.initBuiltin.Do(func() {
+		if s.IgnoreBuiltin {
+			return
+		}
+		for _, schema := range builtin.Schemas.Schemas() {
+			s.setupDefaults(schema)
+			s.schemas.AddSchema(schema)
+		}
+	})
+
 	for _, schema := range schemas.Schemas() {
 		s.setupDefaults(schema)
 		s.schemas.AddSchema(schema)
@@ -118,6 +145,10 @@ func (s *Server) setupDefaults(schema *types.Schema) {
 	if schema.ErrorHandler == nil {
 		schema.ErrorHandler = s.Defaults.ErrorHandler
 	}
+
+	if schema.Store != nil && s.StoreWrapper != nil {
+		schema.Store = s.StoreWrapper(schema.Store)
+	}
 }
 
 func (s *Server) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
@@ -149,23 +180,17 @@ func (s *Server) handle(rw http.ResponseWriter, req *http.Request) (*types.APICo
 		return apiRequest, nil
 	}
 
-	b := builder.NewBuilder(apiRequest)
-
 	if action == nil && apiRequest.Type != "" {
 		var handler types.RequestHandler
 		switch apiRequest.Method {
 		case http.MethodGet:
 			handler = apiRequest.Schema.ListHandler
-			apiRequest.Body = nil
 		case http.MethodPost:
 			handler = apiRequest.Schema.CreateHandler
-			apiRequest.Body, err = b.Construct(apiRequest.Schema, apiRequest.Body, builder.Create)
 		case http.MethodPut:
 			handler = apiRequest.Schema.UpdateHandler
-			apiRequest.Body, err = b.Construct(apiRequest.Schema, apiRequest.Body, builder.Update)
 		case http.MethodDelete:
 			handler = apiRequest.Schema.DeleteHandler
-			apiRequest.Body = nil
 		}
 
 		if err != nil {
@@ -173,7 +198,7 @@ func (s *Server) handle(rw http.ResponseWriter, req *http.Request) (*types.APICo
 		}
 
 		if handler == nil {
-			return apiRequest, httperror.NewAPIError(httperror.NOT_FOUND, "")
+			return apiRequest, httperror.NewAPIError(httperror.NotFound, "")
 		}
 
 		return apiRequest, handler(apiRequest)
@@ -195,15 +220,3 @@ func (s *Server) handleError(apiRequest *types.APIContext, err error) {
 		apiRequest.Schema.ErrorHandler(apiRequest, err)
 	}
 }
-
-func (s *Server) addBuiltins(ctx context.Context) error {
-	if s.IgnoreBuiltin {
-		return nil
-	}
-
-	if err := s.AddSchemas(builtin.Schemas); err != nil {
-		return err
-	}
-
-	return nil
-}
diff --git a/api/validate.go b/api/validate.go
index a2c1b6f7d..0b417f106 100644
--- a/api/validate.go
+++ b/api/validate.go
@@ -28,17 +28,17 @@ func ValidateAction(request *types.APIContext) (*types.Action, error) {
 
 	action, ok := actions[request.Action]
 	if !ok {
-		return nil, httperror.NewAPIError(httperror.INVALID_ACTION, fmt.Sprintf("Invalid action: %s", request.Action))
+		return nil, httperror.NewAPIError(httperror.InvalidAction, fmt.Sprintf("Invalid action: %s", request.Action))
 	}
 
 	if request.ID != "" {
 		resource := request.ReferenceValidator.Lookup(request.Type, request.ID)
 		if resource == nil {
-			return nil, httperror.NewAPIError(httperror.NOT_FOUND, fmt.Sprintf("Failed to find type: %s id: %s", request.Type, request.ID))
+			return nil, httperror.NewAPIError(httperror.NotFound, fmt.Sprintf("Failed to find type: %s id: %s", request.Type, request.ID))
 		}
 
 		if _, ok := resource.Actions[request.Action]; !ok {
-			return nil, httperror.NewAPIError(httperror.INVALID_ACTION, fmt.Sprintf("Invalid action: %s", request.Action))
+			return nil, httperror.NewAPIError(httperror.InvalidAction, fmt.Sprintf("Invalid action: %s", request.Action))
 		}
 	}
 
@@ -55,7 +55,7 @@ func CheckCSRF(rw http.ResponseWriter, req *http.Request) error {
 		bytes := make([]byte, 5)
 		_, err := rand.Read(bytes)
 		if err != nil {
-			return httperror.WrapAPIError(err, httperror.SERVER_ERROR, "Failed in CSRF processing")
+			return httperror.WrapAPIError(err, httperror.ServerError, "Failed in CSRF processing")
 		}
 
 		cookie = &http.Cookie{
@@ -63,7 +63,7 @@ func CheckCSRF(rw http.ResponseWriter, req *http.Request) error {
 			Value: hex.EncodeToString(bytes),
 		}
 	} else if err != nil {
-		return httperror.NewAPIError(httperror.INVALID_CSRF_TOKEN, "Failed to parse cookies")
+		return httperror.NewAPIError(httperror.InvalidCSRFToken, "Failed to parse cookies")
 	} else if req.Method != http.MethodGet {
 		/*
 		 * Very important to use request.getMethod() and not httpRequest.getMethod(). The client can override the HTTP method with _method
@@ -73,7 +73,7 @@ func CheckCSRF(rw http.ResponseWriter, req *http.Request) error {
 		} else if cookie.Value == req.URL.Query().Get(csrfCookie) {
 			// Good
 		} else {
-			return httperror.NewAPIError(httperror.INVALID_CSRF_TOKEN, "Invalid CSRF token")
+			return httperror.NewAPIError(httperror.InvalidCSRFToken, "Invalid CSRF token")
 		}
 	}
 
diff --git a/api/writer/html.go b/api/writer/html.go
index 59b33635e..f12a0aa38 100644
--- a/api/writer/html.go
+++ b/api/writer/html.go
@@ -3,6 +3,7 @@ package writer
 import (
 	"strings"
 
+	"github.com/rancher/norman/api/builtin"
 	"github.com/rancher/norman/types"
 )
 
@@ -11,8 +12,8 @@ var (
 <!DOCTYPE html>
 <!-- If you are reading this, there is a good chance you would prefer sending an
 "Accept: application/json" header and receiving actual JSON responses. -->
-<link rel="stylesheet" type="text/css" href="https://releases.rancher.com/api-ui/1.1.0/ui.min.css" />
-<script src="https://releases.rancher.com/api-ui/1.1.0/ui.min.js"></script>
+<link rel="stylesheet" type="text/css" href="https://releases.rancher.com/api-ui/1.1.1/ui.min.css" />
+<script src="https://releases.rancher.com/api-ui/1.1.1/ui.min.js"></script>
 <script>
 var user = "admin";
 var curlUser='${CATTLE_ACCESS_KEY}:${CATTLE_SECRET_KEY}';
@@ -34,9 +35,9 @@ func (h *HTMLResponseWriter) start(apiContext *types.APIContext, code int, obj i
 
 func (h *HTMLResponseWriter) Write(apiContext *types.APIContext, code int, obj interface{}) {
 	h.start(apiContext, code, obj)
-	schemaSchema := apiContext.Schemas.Schema(nil, "/v3/schema")
+	schemaSchema := apiContext.Schemas.Schema(&builtin.Version, "schema")
 	if schemaSchema != nil {
-		headerString := strings.Replace(start, "%SCHEMAS%", apiContext.URLBuilder.Collection(schemaSchema), 1)
+		headerString := strings.Replace(start, "%SCHEMAS%", apiContext.URLBuilder.Collection(schemaSchema, apiContext.Version), 1)
 		apiContext.Response.Write([]byte(headerString))
 	}
 	h.Body(apiContext, code, obj)
diff --git a/api/writer/json.go b/api/writer/json.go
index 7bd44f0f8..a5873638a 100644
--- a/api/writer/json.go
+++ b/api/writer/json.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/rancher/norman/parse"
 	"github.com/rancher/norman/parse/builder"
 	"github.com/rancher/norman/types"
 	"github.com/sirupsen/logrus"
@@ -130,19 +131,47 @@ func newCollection(apiContext *types.APIContext) *types.GenericCollection {
 
 	if apiContext.Method == http.MethodGet {
 		if apiContext.AccessControl.CanCreate(apiContext.Schema) {
-			result.CreateTypes[apiContext.Schema.ID] = apiContext.URLBuilder.Collection(apiContext.Schema)
+			result.CreateTypes[apiContext.Schema.ID] = apiContext.URLBuilder.Collection(apiContext.Schema, apiContext.Version)
 		}
 	}
 
-	if apiContext.QueryOptions != nil {
-		result.Sort = &apiContext.QueryOptions.Sort
-		result.Sort.Reverse = apiContext.URLBuilder.ReverseSort(result.Sort.Order)
-		result.Pagination = apiContext.QueryOptions.Pagination
-		result.Filters = map[string][]types.Condition{}
+	opts := parse.QueryOptions(apiContext, apiContext.Schema)
+	result.Sort = &opts.Sort
+	result.Sort.Reverse = apiContext.URLBuilder.ReverseSort(result.Sort.Order)
+	result.Sort.Links = map[string]string{}
+	result.Pagination = opts.Pagination
+	result.Filters = map[string][]types.Condition{}
 
-		for _, cond := range apiContext.QueryOptions.Conditions {
-			filters := result.Filters[cond.Field]
-			result.Filters[cond.Field] = append(filters, cond.ToCondition())
+	for _, cond := range opts.Conditions {
+		filters := result.Filters[cond.Field]
+		result.Filters[cond.Field] = append(filters, cond.ToCondition())
+	}
+
+	for name := range apiContext.Schema.CollectionFilters {
+		if _, ok := result.Filters[name]; !ok {
+			result.Filters[name] = nil
+		}
+	}
+
+	for queryField := range apiContext.Schema.CollectionFilters {
+		field, ok := apiContext.Schema.ResourceFields[queryField]
+		if ok && (field.Type == "string" || field.Type == "enum") {
+			result.Sort.Links[queryField] = apiContext.URLBuilder.Sort(queryField)
+		}
+	}
+
+	if result.Pagination.Partial {
+		if result.Pagination.Next != "" {
+			result.Pagination.Next = apiContext.URLBuilder.Marker(result.Pagination.Next)
+		}
+		if result.Pagination.Previous != "" {
+			result.Pagination.Previous = apiContext.URLBuilder.Marker(result.Pagination.Previous)
+		}
+		if result.Pagination.First != "" {
+			result.Pagination.First = apiContext.URLBuilder.Marker(result.Pagination.First)
+		}
+		if result.Pagination.Last != "" {
+			result.Pagination.Last = apiContext.URLBuilder.Marker(result.Pagination.Last)
 		}
 	}
 
diff --git a/clientbase/common.go b/clientbase/common.go
index 16fa88d3f..11cd3de94 100644
--- a/clientbase/common.go
+++ b/clientbase/common.go
@@ -55,7 +55,7 @@ func IsNotFound(err error) bool {
 	return apiError.StatusCode == http.StatusNotFound
 }
 
-func newApiError(resp *http.Response, url string) *APIError {
+func newAPIError(resp *http.Response, url string) *APIError {
 	contents, err := ioutil.ReadAll(resp.Body)
 	var body string
 	if err != nil {
@@ -161,7 +161,7 @@ func NewAPIClient(opts *ClientOpts) (APIBaseClient, error) {
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		return result, newApiError(resp, opts.URL)
+		return result, newAPIError(resp, opts.URL)
 	}
 
 	schemasURLs := resp.Header.Get("X-API-Schemas")
@@ -184,7 +184,7 @@ func NewAPIClient(opts *ClientOpts) (APIBaseClient, error) {
 		defer resp.Body.Close()
 
 		if resp.StatusCode != 200 {
-			return result, newApiError(resp, opts.URL)
+			return result, newAPIError(resp, opts.URL)
 		}
 	}
 
@@ -244,7 +244,7 @@ func (a *APIBaseClient) Post(url string, createObj interface{}, respObject inter
 func (a *APIBaseClient) GetLink(resource types.Resource, link string, respObject interface{}) error {
 	url := resource.Links[link]
 	if url == "" {
-		return fmt.Errorf("Failed to find link: %s", link)
+		return fmt.Errorf("failed to find link: %s", link)
 	}
 
 	return a.Ops.DoGet(url, &types.ListOpts{}, respObject)
@@ -270,12 +270,12 @@ func (a *APIBaseClient) Delete(existing *types.Resource) error {
 }
 
 func (a *APIBaseClient) Reload(existing *types.Resource, output interface{}) error {
-	selfUrl, ok := existing.Links[SELF]
+	selfURL, ok := existing.Links[SELF]
 	if !ok {
-		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+		return fmt.Errorf("failed to find self URL of [%v]", existing)
 	}
 
-	return a.Ops.DoGet(selfUrl, NewListOpts(), output)
+	return a.Ops.DoGet(selfURL, NewListOpts(), output)
 }
 
 func (a *APIBaseClient) Action(schemaType string, action string,
diff --git a/clientbase/ops.go b/clientbase/ops.go
index 0a9fd93e0..d60e6c150 100644
--- a/clientbase/ops.go
+++ b/clientbase/ops.go
@@ -34,7 +34,7 @@ func (a *APIOperations) DoDelete(url string) error {
 	io.Copy(ioutil.Discard, resp.Body)
 
 	if resp.StatusCode >= 300 {
-		return newApiError(resp, url)
+		return newAPIError(resp, url)
 	}
 
 	return nil
@@ -68,7 +68,7 @@ func (a *APIOperations) DoGet(url string, opts *types.ListOpts, respObject inter
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		return newApiError(resp, url)
+		return newAPIError(resp, url)
 	}
 
 	byteContent, err := ioutil.ReadAll(resp.Body)
@@ -97,16 +97,16 @@ func (a *APIOperations) DoList(schemaType string, opts *types.ListOpts, respObje
 		return errors.New("Resource type [" + schemaType + "] is not listable")
 	}
 
-	collectionUrl, ok := schema.Links[COLLECTION]
+	collectionURL, ok := schema.Links[COLLECTION]
 	if !ok {
 		return errors.New("Failed to find collection URL for [" + schemaType + "]")
 	}
 
-	return a.DoGet(collectionUrl, opts, respObject)
+	return a.DoGet(collectionURL, opts, respObject)
 }
 
-func (a *APIOperations) DoNext(nextUrl string, respObject interface{}) error {
-	return a.DoGet(nextUrl, nil, respObject)
+func (a *APIOperations) DoNext(nextURL string, respObject interface{}) error {
+	return a.DoGet(nextURL, nil, respObject)
 }
 
 func (a *APIOperations) DoModify(method string, url string, createObj interface{}, respObject interface{}) error {
@@ -136,7 +136,7 @@ func (a *APIOperations) DoModify(method string, url string, createObj interface{
 	defer resp.Body.Close()
 
 	if resp.StatusCode >= 300 {
-		return newApiError(resp, url)
+		return newAPIError(resp, url)
 	}
 
 	byteContent, err := ioutil.ReadAll(resp.Body)
@@ -170,16 +170,16 @@ func (a *APIOperations) DoCreate(schemaType string, createObj interface{}, respO
 		return errors.New("Resource type [" + schemaType + "] is not creatable")
 	}
 
-	var collectionUrl string
-	collectionUrl, ok = schema.Links[COLLECTION]
+	var collectionURL string
+	collectionURL, ok = schema.Links[COLLECTION]
 	if !ok {
 		// return errors.New("Failed to find collection URL for [" + schemaType + "]")
 		// This is a hack to address https://github.com/rancher/cattle/issues/254
 		re := regexp.MustCompile("schemas.*")
-		collectionUrl = re.ReplaceAllString(schema.Links[SELF], schema.PluralName)
+		collectionURL = re.ReplaceAllString(schema.Links[SELF], schema.PluralName)
 	}
 
-	return a.DoModify("POST", collectionUrl, createObj, respObject)
+	return a.DoModify("POST", collectionURL, createObj, respObject)
 }
 
 func (a *APIOperations) DoUpdate(schemaType string, existing *types.Resource, updates interface{}, respObject interface{}) error {
@@ -187,9 +187,9 @@ func (a *APIOperations) DoUpdate(schemaType string, existing *types.Resource, up
 		return errors.New("Existing object is nil")
 	}
 
-	selfUrl, ok := existing.Links[SELF]
+	selfURL, ok := existing.Links[SELF]
 	if !ok {
-		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+		return fmt.Errorf("failed to find self URL of [%v]", existing)
 	}
 
 	if updates == nil {
@@ -209,7 +209,7 @@ func (a *APIOperations) DoUpdate(schemaType string, existing *types.Resource, up
 		return errors.New("Resource type [" + schemaType + "] is not updatable")
 	}
 
-	return a.DoModify("PUT", selfUrl, updates, respObject)
+	return a.DoModify("PUT", selfURL, updates, respObject)
 }
 
 func (a *APIOperations) DoByID(schemaType string, id string, respObject interface{}) error {
@@ -222,12 +222,12 @@ func (a *APIOperations) DoByID(schemaType string, id string, respObject interfac
 		return errors.New("Resource type [" + schemaType + "] can not be looked up by ID")
 	}
 
-	collectionUrl, ok := schema.Links[COLLECTION]
+	collectionURL, ok := schema.Links[COLLECTION]
 	if !ok {
 		return errors.New("Failed to find collection URL for [" + schemaType + "]")
 	}
 
-	return a.DoGet(collectionUrl+"/"+id, nil, respObject)
+	return a.DoGet(collectionURL+"/"+id, nil, respObject)
 }
 
 func (a *APIOperations) DoResourceDelete(schemaType string, existing *types.Resource) error {
@@ -240,12 +240,12 @@ func (a *APIOperations) DoResourceDelete(schemaType string, existing *types.Reso
 		return errors.New("Resource type [" + schemaType + "] can not be deleted")
 	}
 
-	selfUrl, ok := existing.Links[SELF]
+	selfURL, ok := existing.Links[SELF]
 	if !ok {
-		return errors.New(fmt.Sprintf("Failed to find self URL of [%v]", existing))
+		return fmt.Errorf("failed to find self URL of [%v]", existing)
 	}
 
-	return a.DoDelete(selfUrl)
+	return a.DoDelete(selfURL)
 }
 
 func (a *APIOperations) DoAction(schemaType string, action string,
@@ -255,9 +255,9 @@ func (a *APIOperations) DoAction(schemaType string, action string,
 		return errors.New("Existing object is nil")
 	}
 
-	actionUrl, ok := existing.Actions[action]
+	actionURL, ok := existing.Actions[action]
 	if !ok {
-		return errors.New(fmt.Sprintf("Action [%v] not available on [%v]", action, existing))
+		return fmt.Errorf("action [%v] not available on [%v]", action, existing)
 	}
 
 	_, ok = a.Types[schemaType]
@@ -278,7 +278,7 @@ func (a *APIOperations) DoAction(schemaType string, action string,
 		input = bytes.NewBuffer(bodyContent)
 	}
 
-	req, err := http.NewRequest("POST", actionUrl, input)
+	req, err := http.NewRequest("POST", actionURL, input)
 	if err != nil {
 		return err
 	}
@@ -295,7 +295,7 @@ func (a *APIOperations) DoAction(schemaType string, action string,
 	defer resp.Body.Close()
 
 	if resp.StatusCode >= 300 {
-		return newApiError(resp, actionUrl)
+		return newAPIError(resp, actionURL)
 	}
 
 	byteContent, err := ioutil.ReadAll(resp.Body)
diff --git a/controller/generic_controller.go b/controller/generic_controller.go
index 9d41235e1..bbad65093 100644
--- a/controller/generic_controller.go
+++ b/controller/generic_controller.go
@@ -69,12 +69,12 @@ func (g *genericController) AddHandler(handler HandlerFunc) {
 	g.handlers = append(g.handlers, handler)
 }
 
-func (g *genericController) Start(threadiness int, ctx context.Context) error {
+func (g *genericController) Start(ctx context.Context, threadiness int) error {
 	g.Lock()
 	defer g.Unlock()
 
 	if !g.running {
-		go g.run(threadiness, ctx)
+		go g.run(ctx, threadiness)
 	}
 
 	g.running = true
@@ -88,7 +88,7 @@ func (g *genericController) queueObject(obj interface{}) {
 	}
 }
 
-func (g *genericController) run(threadiness int, ctx context.Context) {
+func (g *genericController) run(ctx context.Context, threadiness int) {
 	defer utilruntime.HandleCrash()
 	defer g.queue.ShutDown()
 
diff --git a/generator/funcs.go b/generator/funcs.go
index c744b373c..6af1d3e7f 100644
--- a/generator/funcs.go
+++ b/generator/funcs.go
@@ -11,11 +11,10 @@ import (
 
 func funcs() template.FuncMap {
 	return template.FuncMap{
-		"toLowerCamelCase": convert.LowerTitle,
-		"capitalize":       convert.Capitalize,
-		"upper":            strings.ToUpper,
-		"toLower":          strings.ToLower,
-		"hasGet":           hasGet,
+		"capitalize": convert.Capitalize,
+		"upper":      strings.ToUpper,
+		"toLower":    strings.ToLower,
+		"hasGet":     hasGet,
 	}
 }
 
diff --git a/generator/generator.go b/generator/generator.go
index 0f599f7d3..696754257 100644
--- a/generator/generator.go
+++ b/generator/generator.go
@@ -30,6 +30,11 @@ var (
 	underscoreRegexp = regexp.MustCompile(`([a-z])([A-Z])`)
 )
 
+type fieldInfo struct {
+	Name string
+	Type string
+}
+
 func getGoType(field types.Field, schema *types.Schema, schemas *types.Schemas) string {
 	return getTypeString(field.Nullable, field.Type, schema, schemas)
 }
@@ -87,10 +92,13 @@ func getTypeString(nullable bool, typeName string, schema *types.Schema, schemas
 	return name
 }
 
-func getTypeMap(schema *types.Schema, schemas *types.Schemas) map[string]string {
-	result := map[string]string{}
-	for _, field := range schema.ResourceFields {
-		result[field.CodeName] = getGoType(field, schema, schemas)
+func getTypeMap(schema *types.Schema, schemas *types.Schemas) map[string]fieldInfo {
+	result := map[string]fieldInfo{}
+	for name, field := range schema.ResourceFields {
+		result[field.CodeName] = fieldInfo{
+			Name: name,
+			Type: getGoType(field, schema, schemas),
+		}
 	}
 	return result
 }
@@ -143,9 +151,7 @@ func generateController(outputDir string, schema *types.Schema, schemas *types.S
 	}
 
 	return typeTemplate.Execute(output, map[string]interface{}{
-		"schema":          schema,
-		"structFields":    getTypeMap(schema, schemas),
-		"resourceActions": getResourceActions(schema, schemas),
+		"schema": schema,
 	})
 }
 
diff --git a/generator/type_template.go b/generator/type_template.go
index 7f05c5677..e790936a3 100644
--- a/generator/type_template.go
+++ b/generator/type_template.go
@@ -11,7 +11,7 @@ import (
 const (
     {{.schema.CodeName}}Type = "{{.schema.ID}}"
 {{- range $key, $value := .structFields}}
-	{{$.schema.CodeName}}Field{{$key}} = "{{$key | toLowerCamelCase }}"
+	{{$.schema.CodeName}}Field{{$key}} = "{{$value.Name}}"
 {{- end}}
 )
 
@@ -20,7 +20,7 @@ type {{.schema.CodeName}} struct {
     types.Resource
 {{- end}}
     {{- range $key, $value := .structFields}}
-        {{$key}} {{$value}} %BACK%json:"{{$key | toLowerCamelCase }},omitempty"%BACK%
+        {{$key}} {{$value.Type}} %BACK%json:"{{$value.Name}},omitempty"%BACK%
     {{- end}}
 }
 
diff --git a/httperror/error.go b/httperror/error.go
index 51f1aeb9e..022ec4d9c 100644
--- a/httperror/error.go
+++ b/httperror/error.go
@@ -5,28 +5,28 @@ import (
 )
 
 var (
-	INVALID_DATE_FORMAT  = ErrorCode{"InvalidDateFormat", 422}
-	INVALID_FORMAT       = ErrorCode{"InvalidFormat", 422}
-	INVALID_REFERENCE    = ErrorCode{"InvalidReference", 422}
-	NOT_NULLABLE         = ErrorCode{"NotNullable", 422}
-	NOT_UNIQUE           = ErrorCode{"NotUnique", 422}
-	MIN_LIMIT_EXCEEDED   = ErrorCode{"MinLimitExceeded", 422}
-	MAX_LIMIT_EXCEEDED   = ErrorCode{"MaxLimitExceeded", 422}
-	MIN_LENGTH_EXCEEDED  = ErrorCode{"MinLengthExceeded", 422}
-	MAX_LENGTH_EXCEEDED  = ErrorCode{"MaxLengthExceeded", 422}
-	INVALID_OPTION       = ErrorCode{"InvalidOption", 422}
-	INVALID_CHARACTERS   = ErrorCode{"InvalidCharacters", 422}
-	MISSING_REQUIRED     = ErrorCode{"MissingRequired", 422}
-	INVALID_CSRF_TOKEN   = ErrorCode{"InvalidCSRFToken", 422}
-	INVALID_ACTION       = ErrorCode{"InvalidAction", 422}
-	INVALID_BODY_CONTENT = ErrorCode{"InvalidBodyContent", 422}
-	INVALID_TYPE         = ErrorCode{"InvalidType", 422}
-	ACTION_NOT_AVAILABLE = ErrorCode{"ActionNotAvailable", 404}
-	INVALID_STATE        = ErrorCode{"InvalidState", 422}
-	SERVER_ERROR         = ErrorCode{"ServerError", 500}
+	InvalidDateFormat  = ErrorCode{"InvalidDateFormat", 422}
+	InvalidFormat      = ErrorCode{"InvalidFormat", 422}
+	InvalidReference   = ErrorCode{"InvalidReference", 422}
+	NotNullable        = ErrorCode{"NotNullable", 422}
+	NotUnique          = ErrorCode{"NotUnique", 422}
+	MinLimitExceeded   = ErrorCode{"MinLimitExceeded", 422}
+	MaxLimitExceeded   = ErrorCode{"MaxLimitExceeded", 422}
+	MinLengthExceeded  = ErrorCode{"MinLengthExceeded", 422}
+	MaxLengthExceeded  = ErrorCode{"MaxLengthExceeded", 422}
+	InvalidOption      = ErrorCode{"InvalidOption", 422}
+	InvalidCharacters  = ErrorCode{"InvalidCharacters", 422}
+	MissingRequired    = ErrorCode{"MissingRequired", 422}
+	InvalidCSRFToken   = ErrorCode{"InvalidCSRFToken", 422}
+	InvalidAction      = ErrorCode{"InvalidAction", 422}
+	InvalidBodyContent = ErrorCode{"InvalidBodyContent", 422}
+	InvalidType        = ErrorCode{"InvalidType", 422}
+	ActionNotAvailable = ErrorCode{"ActionNotAvailable", 404}
+	InvalidState       = ErrorCode{"InvalidState", 422}
+	ServerError        = ErrorCode{"ServerError", 500}
 
-	METHOD_NOT_ALLOWED = ErrorCode{"MethodNotAllow", 405}
-	NOT_FOUND          = ErrorCode{"NotFound", 404}
+	MethodNotAllowed = ErrorCode{"MethodNotAllow", 405}
+	NotFound         = ErrorCode{"NotFound", 404}
 )
 
 type ErrorCode struct {
diff --git a/httperror/handler.go b/httperror/handler.go
index 5f8fc334b..b74aab175 100644
--- a/httperror/handler.go
+++ b/httperror/handler.go
@@ -12,7 +12,7 @@ func ErrorHandler(request *types.APIContext, err error) {
 	} else {
 		logrus.Errorf("Unknown error: %v", err)
 		error = &APIError{
-			code:    SERVER_ERROR,
+			code:    ServerError,
 			message: err.Error(),
 		}
 	}
@@ -23,7 +23,7 @@ func ErrorHandler(request *types.APIContext, err error) {
 
 func toError(apiError *APIError) map[string]interface{} {
 	e := map[string]interface{}{
-		"type":    "/v3/schema",
+		"type":    "/v1-meta/schemas/error",
 		"code":    apiError.code.code,
 		"message": apiError.message,
 	}
diff --git a/parse/builder/builder.go b/parse/builder/builder.go
index af44acd71..82f753a9a 100644
--- a/parse/builder/builder.go
+++ b/parse/builder/builder.go
@@ -51,7 +51,7 @@ func (b *Builder) copyInputs(schema *types.Schema, input map[string]interface{},
 		wasNull := value == nil && (field.Nullable || field.Default == nil)
 		value, err := b.convert(field.Type, value, op)
 		if err != nil {
-			return httperror.WrapFieldAPIError(err, httperror.INVALID_FORMAT, fieldName, err.Error())
+			return httperror.WrapFieldAPIError(err, httperror.InvalidFormat, fieldName, err.Error())
 		}
 
 		if value != nil || wasNull {
@@ -59,7 +59,7 @@ func (b *Builder) copyInputs(schema *types.Schema, input map[string]interface{},
 				if slice, ok := value.([]interface{}); ok {
 					for _, sliceValue := range slice {
 						if sliceValue == nil {
-							return httperror.NewFieldAPIError(httperror.NOT_NULLABLE, fieldName, "Individual array values can not be null")
+							return httperror.NewFieldAPIError(httperror.NotNullable, fieldName, "Individual array values can not be null")
 						}
 						if err := checkFieldCriteria(fieldName, field, sliceValue); err != nil {
 							return err
@@ -82,6 +82,11 @@ func (b *Builder) copyInputs(schema *types.Schema, input map[string]interface{},
 		}
 	}
 
+	if op == List {
+		result["type"] = input["type"]
+		result["id"] = input["id"]
+	}
+
 	return nil
 }
 
@@ -95,7 +100,7 @@ func (b *Builder) checkDefaultAndRequired(schema *types.Schema, input map[string
 		_, hasKey = result[fieldName]
 		if op == Create && fieldMatchesOp(field, Create) && field.Required {
 			if !hasKey {
-				return httperror.NewFieldAPIError(httperror.MISSING_REQUIRED, fieldName, "")
+				return httperror.NewFieldAPIError(httperror.MissingRequired, fieldName, "")
 			}
 
 			if definition.IsArrayType(field.Type) {
@@ -104,7 +109,7 @@ func (b *Builder) checkDefaultAndRequired(schema *types.Schema, input map[string
 					return err
 				}
 				if len(slice) == 0 {
-					return httperror.NewFieldAPIError(httperror.MISSING_REQUIRED, fieldName, "")
+					return httperror.NewFieldAPIError(httperror.MissingRequired, fieldName, "")
 				}
 			}
 		}
@@ -137,25 +142,25 @@ func checkFieldCriteria(fieldName string, field types.Field, value interface{})
 		strVal = fmt.Sprint(value)
 	}
 
-	if value == nil && !field.Nullable {
-		return httperror.NewFieldAPIError(httperror.NOT_NULLABLE, fieldName, "")
+	if (value == nil || value == "") && !field.Nullable {
+		return httperror.NewFieldAPIError(httperror.NotNullable, fieldName, "")
 	}
 
 	if isNum {
 		if field.Min != nil && numVal < *field.Min {
-			return httperror.NewFieldAPIError(httperror.MIN_LIMIT_EXCEEDED, fieldName, "")
+			return httperror.NewFieldAPIError(httperror.MinLimitExceeded, fieldName, "")
 		}
 		if field.Max != nil && numVal > *field.Max {
-			return httperror.NewFieldAPIError(httperror.MAX_LIMIT_EXCEEDED, fieldName, "")
+			return httperror.NewFieldAPIError(httperror.MaxLimitExceeded, fieldName, "")
 		}
 	}
 
 	if hasStrVal {
 		if field.MinLength != nil && int64(len(strVal)) < *field.MinLength {
-			return httperror.NewFieldAPIError(httperror.MIN_LENGTH_EXCEEDED, fieldName, "")
+			return httperror.NewFieldAPIError(httperror.MinLengthExceeded, fieldName, "")
 		}
 		if field.MaxLength != nil && int64(len(strVal)) > *field.MaxLength {
-			return httperror.NewFieldAPIError(httperror.MAX_LENGTH_EXCEEDED, fieldName, "")
+			return httperror.NewFieldAPIError(httperror.MaxLengthExceeded, fieldName, "")
 		}
 	}
 
@@ -170,7 +175,7 @@ func checkFieldCriteria(fieldName string, field types.Field, value interface{})
 			}
 
 			if !found {
-				httperror.NewFieldAPIError(httperror.INVALID_OPTION, fieldName, "")
+				httperror.NewFieldAPIError(httperror.InvalidOption, fieldName, "")
 			}
 		}
 	}
@@ -178,7 +183,7 @@ func checkFieldCriteria(fieldName string, field types.Field, value interface{})
 	if len(field.ValidChars) > 0 && hasStrVal {
 		for _, c := range strVal {
 			if !strings.ContainsRune(field.ValidChars, c) {
-				httperror.NewFieldAPIError(httperror.INVALID_CHARACTERS, fieldName, "")
+				httperror.NewFieldAPIError(httperror.InvalidCharacters, fieldName, "")
 			}
 
 		}
@@ -186,7 +191,7 @@ func checkFieldCriteria(fieldName string, field types.Field, value interface{})
 
 	if len(field.InvalidChars) > 0 && hasStrVal {
 		if strings.ContainsAny(strVal, field.InvalidChars) {
-			httperror.NewFieldAPIError(httperror.INVALID_CHARACTERS, fieldName, "")
+			httperror.NewFieldAPIError(httperror.InvalidCharacters, fieldName, "")
 		}
 	}
 
@@ -211,7 +216,11 @@ func (b *Builder) convert(fieldType string, value interface{}, op Operation) (in
 	case "json":
 		return value, nil
 	case "date":
-		return convert.ToString(value), nil
+		v := convert.ToString(value)
+		if v == "" {
+			return nil, nil
+		}
+		return v, nil
 	case "boolean":
 		return convert.ToBool(value), nil
 	case "enum":
@@ -232,12 +241,12 @@ func (b *Builder) convert(fieldType string, value interface{}, op Operation) (in
 func (b *Builder) convertType(fieldType string, value interface{}, op Operation) (interface{}, error) {
 	schema := b.Schemas.Schema(b.Version, fieldType)
 	if schema == nil {
-		return nil, httperror.NewAPIError(httperror.INVALID_TYPE, "Failed to find type "+fieldType)
+		return nil, httperror.NewAPIError(httperror.InvalidType, "Failed to find type "+fieldType)
 	}
 
 	mapValue, ok := value.(map[string]interface{})
 	if !ok {
-		return nil, httperror.NewAPIError(httperror.INVALID_FORMAT, fmt.Sprintf("Value can not be converted to type %s: %v", fieldType, value))
+		return nil, httperror.NewAPIError(httperror.InvalidFormat, fmt.Sprintf("Value can not be converted to type %s: %v", fieldType, value))
 	}
 
 	return b.Construct(schema, mapValue, op)
@@ -247,7 +256,7 @@ func (b *Builder) convertReferenceType(fieldType string, value interface{}) (str
 	subType := definition.SubType(fieldType)
 	strVal := convert.ToString(value)
 	if b.RefValidator != nil && !b.RefValidator.Validate(subType, strVal) {
-		return "", httperror.NewAPIError(httperror.INVALID_REFERENCE, fmt.Sprintf("Not found type: %s id: %s", subType, strVal))
+		return "", httperror.NewAPIError(httperror.InvalidReference, fmt.Sprintf("Not found type: %s id: %s", subType, strVal))
 	}
 	return strVal, nil
 }
@@ -293,7 +302,7 @@ func (b *Builder) convertMap(fieldType string, value interface{}, op Operation)
 	for key, value := range mapValue {
 		val, err := b.convert(subType, value, op)
 		if err != nil {
-			return nil, httperror.WrapAPIError(err, httperror.INVALID_FORMAT, err.Error())
+			return nil, httperror.WrapAPIError(err, httperror.InvalidFormat, err.Error())
 		}
 		result[key] = val
 	}
diff --git a/parse/parse_collection.go b/parse/collection.go
similarity index 80%
rename from parse/parse_collection.go
rename to parse/collection.go
index a47de015c..c6e2926f9 100644
--- a/parse/parse_collection.go
+++ b/parse/collection.go
@@ -9,13 +9,14 @@ import (
 )
 
 var (
-	defaultLimit = int64(100)
+	defaultLimit = int64(1000)
 	maxLimit     = int64(3000)
 )
 
-func QueryOptions(req *http.Request, schema *types.Schema) *types.QueryOptions {
+func QueryOptions(apiContext *types.APIContext, schema *types.Schema) types.QueryOptions {
+	req := apiContext.Request
 	if req.Method != http.MethodGet {
-		return nil
+		return types.QueryOptions{}
 	}
 
 	result := &types.QueryOptions{}
@@ -24,7 +25,7 @@ func QueryOptions(req *http.Request, schema *types.Schema) *types.QueryOptions {
 	result.Pagination = parsePagination(req)
 	result.Conditions = parseFilters(schema, req)
 
-	return result
+	return *result
 }
 
 func parseOrder(req *http.Request) types.SortOrder {
@@ -64,7 +65,7 @@ func parsePagination(req *http.Request) *types.Pagination {
 
 		if limitInt > maxLimit {
 			result.Limit = &maxLimit
-		} else if limitInt > 0 {
+		} else if limitInt >= 0 {
 			result.Limit = &limitInt
 		}
 	}
@@ -72,7 +73,7 @@ func parsePagination(req *http.Request) *types.Pagination {
 	return result
 }
 
-func parseNameAndOp(value string) (string, string) {
+func parseNameAndOp(value string) (string, types.ModifierType) {
 	name := value
 	op := "eq"
 
@@ -82,11 +83,11 @@ func parseNameAndOp(value string) (string, string) {
 		name = value[0:idx]
 	}
 
-	return name, op
+	return name, types.ModifierType(op)
 }
 
 func parseFilters(schema *types.Schema, req *http.Request) []*types.QueryCondition {
-	conditions := []*types.QueryCondition{}
+	var conditions []*types.QueryCondition
 	for key, values := range req.URL.Query() {
 		name, op := parseNameAndOp(key)
 		filter, ok := schema.CollectionFilters[name]
@@ -99,12 +100,7 @@ func parseFilters(schema *types.Schema, req *http.Request) []*types.QueryConditi
 				continue
 			}
 
-			genericValues := []interface{}{}
-			for _, value := range values {
-				genericValues = append(genericValues, value)
-			}
-
-			conditions = append(conditions, types.NewConditionFromString(name, mod, genericValues))
+			conditions = append(conditions, types.NewConditionFromString(name, mod, values...))
 		}
 	}
 
diff --git a/parse/parse.go b/parse/parse.go
index f7e0d5094..99e6df6d2 100644
--- a/parse/parse.go
+++ b/parse/parse.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/rancher/norman/api/builtin"
+	"github.com/rancher/norman/httperror"
 	"github.com/rancher/norman/types"
 	"github.com/rancher/norman/urlbuilder"
 )
@@ -22,7 +23,9 @@ var (
 	}
 )
 
-func Parse(rw http.ResponseWriter, req *http.Request, schemas *types.Schemas) (*types.APIContext, error) {
+type ResolverFunc func(typeName string, context *types.APIContext) error
+
+func Parse(rw http.ResponseWriter, req *http.Request, schemas *types.Schemas, resolverFunc ResolverFunc) (*types.APIContext, error) {
 	var err error
 
 	result := &types.APIContext{
@@ -45,17 +48,15 @@ func Parse(rw http.ResponseWriter, req *http.Request, schemas *types.Schemas) (*
 
 	result.Method = parseMethod(req)
 	result.Action, result.Method = parseAction(req, result.Method)
-	result.Body, err = parseBody(req)
-	if err != nil {
-		return result, err
-	}
 
 	result.URLBuilder, err = urlbuilder.New(req, *result.Version, result.Schemas)
 	if err != nil {
 		return result, err
 	}
 
-	parsePath(result, req)
+	if err := parsePath(result, req, resolverFunc); err != nil {
+		return result, err
+	}
 
 	if result.Schema == nil {
 		result.Method = http.MethodGet
@@ -74,7 +75,8 @@ func Parse(rw http.ResponseWriter, req *http.Request, schemas *types.Schemas) (*
 
 func parseSubContext(parts []string, apiRequest *types.APIContext) []string {
 	subContext := ""
-	apiRequest.SubContext = map[string]interface{}{}
+	apiRequest.SubContext = map[string]string{}
+	apiRequest.Attributes = map[string]interface{}{}
 
 	for len(parts) > 3 && apiRequest.Version != nil {
 		resourceType := parts[1]
@@ -100,9 +102,27 @@ func parseSubContext(parts []string, apiRequest *types.APIContext) []string {
 	return parts
 }
 
-func parsePath(apiRequest *types.APIContext, request *http.Request) {
+func DefaultResolver(typeName string, apiContext *types.APIContext) error {
+	if typeName == "" {
+		return nil
+	}
+
+	schema := apiContext.Schemas.Schema(apiContext.Version, typeName)
+	if schema == nil && (typeName == builtin.Schema.ID || typeName == builtin.Schema.PluralName) {
+		// Schemas are special, we include it as though part of the API request version
+		schema = apiContext.Schemas.Schema(&builtin.Version, typeName)
+	}
+	if schema == nil {
+		return nil
+	}
+
+	apiContext.Schema = schema
+	return nil
+}
+
+func parsePath(apiRequest *types.APIContext, request *http.Request, resolverFunc ResolverFunc) error {
 	if apiRequest.Version == nil {
-		return
+		return nil
 	}
 
 	path := request.URL.Path
@@ -110,38 +130,38 @@ func parsePath(apiRequest *types.APIContext, request *http.Request) {
 
 	versionPrefix := apiRequest.Version.Path
 	if !strings.HasPrefix(path, versionPrefix) {
-		return
+		return nil
 	}
 
 	parts := strings.Split(path[len(versionPrefix):], "/")
 	parts = parseSubContext(parts, apiRequest)
 
 	if len(parts) > 4 {
-		return
+		return httperror.NewAPIError(httperror.NotFound, "No handler for path")
 	}
 
 	typeName := safeIndex(parts, 1)
 	id := safeIndex(parts, 2)
 	link := safeIndex(parts, 3)
 
-	if typeName == "" {
-		return
+	if err := resolverFunc(typeName, apiRequest); err != nil {
+		return err
 	}
 
-	schema := apiRequest.Schemas.Schema(apiRequest.Version, typeName)
-	if schema == nil {
-		return
+	if apiRequest.Schema == nil {
+		return nil
 	}
 
-	apiRequest.Schema = schema
-	apiRequest.Type = schema.ID
+	apiRequest.Type = apiRequest.Schema.ID
 
 	if id == "" {
-		return
+		return nil
 	}
 
 	apiRequest.ID = id
 	apiRequest.Link = link
+
+	return nil
 }
 
 func safeIndex(slice []string, index int) string {
@@ -166,9 +186,8 @@ func parseResponseFormat(req *http.Request) string {
 	// User agent has Mozilla and browser accepts */*
 	if IsBrowser(req, true) {
 		return "html"
-	} else {
-		return "json"
 	}
+	return "json"
 }
 
 func parseMethod(req *http.Request) string {
@@ -206,7 +225,7 @@ func parseVersion(schemas *types.Schemas, path string) *types.APIVersion {
 	return nil
 }
 
-func parseBody(req *http.Request) (map[string]interface{}, error) {
+func Body(req *http.Request) (map[string]interface{}, error) {
 	req.ParseMultipartForm(maxFormSize)
 	if req.MultipartForm != nil {
 		return valuesToBody(req.MultipartForm.Value), nil
diff --git a/parse/read_input.go b/parse/read_input.go
index d5d555e47..03fb45455 100644
--- a/parse/read_input.go
+++ b/parse/read_input.go
@@ -24,13 +24,13 @@ func ReadBody(req *http.Request) (map[string]interface{}, error) {
 
 	content, err := ioutil.ReadAll(io.LimitReader(req.Body, reqMaxSize))
 	if err != nil {
-		return nil, httperror.NewAPIError(httperror.INVALID_BODY_CONTENT,
+		return nil, httperror.NewAPIError(httperror.InvalidBodyContent,
 			fmt.Sprintf("Body content longer than %d bytes", reqMaxSize-1))
 	}
 
 	data := map[string]interface{}{}
 	if err := json.Unmarshal(content, &data); err != nil {
-		return nil, httperror.NewAPIError(httperror.INVALID_BODY_CONTENT,
+		return nil, httperror.NewAPIError(httperror.InvalidBodyContent,
 			fmt.Sprintf("Failed to parse body: %v", err))
 	}
 
diff --git a/parse/subcontext.go b/parse/subcontext.go
new file mode 100644
index 000000000..9944ba9da
--- /dev/null
+++ b/parse/subcontext.go
@@ -0,0 +1,50 @@
+package parse
+
+import (
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
+)
+
+type DefaultSubContextAttributeProvider struct {
+}
+
+func (d *DefaultSubContextAttributeProvider) Query(apiContext *types.APIContext, schema *types.Schema) []*types.QueryCondition {
+	var result []*types.QueryCondition
+
+	for name, value := range d.create(apiContext, schema) {
+		result = append(result, types.NewConditionFromString(name, types.ModifierEQ, value))
+	}
+
+	return result
+}
+
+func (d *DefaultSubContextAttributeProvider) Create(apiContext *types.APIContext, schema *types.Schema) map[string]interface{} {
+	result := map[string]interface{}{}
+	for key, value := range d.create(apiContext, schema) {
+		result[key] = value
+	}
+	return result
+}
+
+func (d *DefaultSubContextAttributeProvider) create(apiContext *types.APIContext, schema *types.Schema) map[string]string {
+	result := map[string]string{}
+
+	for subContext, value := range apiContext.SubContext {
+		subContextSchema := apiContext.Schemas.SubContext(subContext)
+		if subContextSchema == nil {
+			continue
+		}
+
+		ref := convert.ToReference(subContextSchema.ID)
+		fullRef := convert.ToFullReference(subContextSchema.Version.Path, subContextSchema.ID)
+
+		for name, field := range schema.ResourceFields {
+			if field.Type == ref || field.Type == fullRef {
+				result[name] = value
+				break
+			}
+		}
+	}
+
+	return result
+}
diff --git a/parse/validate.go b/parse/validate.go
index ff782e58c..745e5510f 100644
--- a/parse/validate.go
+++ b/parse/validate.go
@@ -23,7 +23,7 @@ func ValidateMethod(request *types.APIContext) error {
 	}
 
 	if !supportedMethods[request.Method] {
-		return httperror.NewAPIError(httperror.METHOD_NOT_ALLOWED, fmt.Sprintf("Method %s not supported", request.Method))
+		return httperror.NewAPIError(httperror.MethodNotAllowed, fmt.Sprintf("Method %s not supported", request.Method))
 	}
 
 	if request.Type == "" || request.Schema == nil {
@@ -41,5 +41,5 @@ func ValidateMethod(request *types.APIContext) error {
 		}
 	}
 
-	return httperror.NewAPIError(httperror.METHOD_NOT_ALLOWED, fmt.Sprintf("Method %s not supported", request.Method))
+	return httperror.NewAPIError(httperror.MethodNotAllowed, fmt.Sprintf("Method %s not supported", request.Method))
 }
diff --git a/scripts/build b/scripts/build
index 105153b05..d4644c72d 100755
--- a/scripts/build
+++ b/scripts/build
@@ -7,4 +7,4 @@ cd $(dirname $0)/..
 
 mkdir -p bin
 [ "$(uname)" != "Darwin" ] && LINKFLAGS="-linkmode external -extldflags -static -s"
-CGO_ENABLED=0 go build -ldflags "-X main.VERSION=$VERSION $LINKFLAGS" -o bin/norman
+CGO_ENABLED=0 go build -ldflags "-X main.VERSION=$VERSION $LINKFLAGS" -o bin/norman ./example
diff --git a/scripts/ci b/scripts/ci
index e6fae796b..ea9a3805b 100755
--- a/scripts/ci
+++ b/scripts/ci
@@ -4,6 +4,5 @@ set -e
 cd $(dirname $0)
 
 ./build
-./test
 ./validate
 ./package
diff --git a/scripts/test b/scripts/test
index 78d0797a5..567079467 100755
--- a/scripts/test
+++ b/scripts/test
@@ -5,7 +5,7 @@ cd $(dirname $0)/..
 
 echo Running tests
 
-PACKAGES=". $(find -name '*.go' | xargs -I{} dirname {} |  cut -f2 -d/ | sort -u | grep -Ev '(^\.$|.git|.trash-cache|vendor|bin)' | sed -e 's!^!./!' -e 's!$!/...!')"
+PACKAGES="$(find -name '*.go' | xargs -I{} dirname {} |  cut -f2 -d/ | sort -u | grep -Ev '(^\.$|.git|.trash-cache|vendor|bin)' | sed -e 's!^!./!' -e 's!$!/...!')"
 
 [ "${ARCH}" == "amd64" ] && RACE=-race
 go test ${RACE} -cover -tags=test ${PACKAGES}
diff --git a/scripts/validate b/scripts/validate
index 17f8372eb..ff9e078ee 100755
--- a/scripts/validate
+++ b/scripts/validate
@@ -5,7 +5,7 @@ cd $(dirname $0)/..
 
 echo Running validation
 
-PACKAGES=". $(find -name '*.go' | xargs -I{} dirname {} |  cut -f2 -d/ | sort -u | grep -Ev '(^\.$|.git|.trash-cache|vendor|bin)' | sed -e 's!^!./!' -e 's!$!/...!')"
+PACKAGES="$(find -name '*.go' | xargs -I{} dirname {} |  cut -f2 -d/ | sort -u | grep -Ev '(^\.$|.git|.trash-cache|vendor|bin)' | sed -e 's!^!./!' -e 's!$!/...!')"
 
 echo Running: go vet
 go vet ${PACKAGES}
diff --git a/server/server.go b/server/server.go
index adec69c88..dab6ba5f3 100644
--- a/server/server.go
+++ b/server/server.go
@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"net/http"
 
 	"github.com/pkg/errors"
 	"github.com/rancher/norman/api"
@@ -14,7 +13,7 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 )
 
-func NewAPIServer(ctx context.Context, kubeConfig string, schemas *types.Schemas) (http.Handler, error) {
+func NewAPIServer(ctx context.Context, kubeConfig string, schemas *types.Schemas) (*api.Server, error) {
 	config, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to build kubeConfig")
@@ -22,7 +21,7 @@ func NewAPIServer(ctx context.Context, kubeConfig string, schemas *types.Schemas
 	return NewAPIServerFromConfig(ctx, config, schemas)
 }
 
-func NewClients(kubeConfig string) (*rest.RESTClient, clientset.Interface, error) {
+func NewClients(kubeConfig string) (rest.Interface, clientset.Interface, error) {
 	config, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
 	if err != nil {
 		return nil, nil, err
@@ -30,7 +29,7 @@ func NewClients(kubeConfig string) (*rest.RESTClient, clientset.Interface, error
 	return NewClientsFromConfig(config)
 }
 
-func NewClientsFromConfig(config *rest.Config) (*rest.RESTClient, clientset.Interface, error) {
+func NewClientsFromConfig(config *rest.Config) (rest.Interface, clientset.Interface, error) {
 	dynamicConfig := *config
 	if dynamicConfig.NegotiatedSerializer == nil {
 		configConfig := dynamic.ContentConfig()
@@ -50,7 +49,7 @@ func NewClientsFromConfig(config *rest.Config) (*rest.RESTClient, clientset.Inte
 	return k8sClient, apiExtClient, nil
 }
 
-func NewAPIServerFromConfig(ctx context.Context, config *rest.Config, schemas *types.Schemas) (http.Handler, error) {
+func NewAPIServerFromConfig(ctx context.Context, config *rest.Config, schemas *types.Schemas) (*api.Server, error) {
 	k8sClient, apiExtClient, err := NewClientsFromConfig(config)
 	if err != nil {
 		return nil, err
@@ -58,17 +57,12 @@ func NewAPIServerFromConfig(ctx context.Context, config *rest.Config, schemas *t
 	return NewAPIServerFromClients(ctx, k8sClient, apiExtClient, schemas)
 }
 
-func NewAPIServerFromClients(ctx context.Context, k8sClient *rest.RESTClient, apiExtClient clientset.Interface, schemas *types.Schemas) (http.Handler, error) {
+func NewAPIServerFromClients(ctx context.Context, k8sClient rest.Interface, apiExtClient clientset.Interface, schemas *types.Schemas) (*api.Server, error) {
 	store := crd.NewCRDStore(apiExtClient, k8sClient)
 	if err := store.AddSchemas(ctx, schemas); err != nil {
 		return nil, err
 	}
 
 	server := api.NewAPIServer()
-	if err := server.AddSchemas(schemas); err != nil {
-		return nil, err
-	}
-
-	err := server.Start(ctx)
-	return server, err
+	return server, server.AddSchemas(schemas)
 }
diff --git a/store/crd/crd_store.go b/store/crd/crd_store.go
index 52d89e531..0f3fc0936 100644
--- a/store/crd/crd_store.go
+++ b/store/crd/crd_store.go
@@ -6,13 +6,14 @@ import (
 	"strings"
 	"time"
 
+	"github.com/rancher/norman/store/proxy"
 	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/convert"
 	"github.com/sirupsen/logrus"
 	apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
 	apiextclientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/rest"
 )
@@ -21,230 +22,55 @@ type Store struct {
 	schemas         []*types.Schema
 	apiExtClientSet apiextclientset.Interface
 	k8sClient       rest.Interface
-	schemaStatus    map[*types.Schema]*apiext.CustomResourceDefinition
+	schemaStores    map[*types.Schema]*proxy.Store
 }
 
 func NewCRDStore(apiExtClientSet apiextclientset.Interface, k8sClient rest.Interface) *Store {
 	return &Store{
 		apiExtClientSet: apiExtClientSet,
 		k8sClient:       k8sClient,
-		schemaStatus:    map[*types.Schema]*apiext.CustomResourceDefinition{},
+		schemaStores:    map[*types.Schema]*proxy.Store{},
 	}
 }
 
 func (c *Store) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
-	crd, ok := c.schemaStatus[schema]
+	store, ok := c.schemaStores[schema]
 	if !ok {
 		return nil, nil
 	}
-
-	namespace := ""
-	parts := strings.SplitN(id, ":", 2)
-
-	if len(parts) == 2 {
-		namespace = parts[0]
-		id = parts[1]
-	}
-
-	req := c.k8sClient.Get().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural).
-		Name(id)
-
-	if namespace != "" {
-		req.Namespace(namespace)
-	}
-
-	result := &unstructured.Unstructured{}
-	err := req.Do().Into(result)
-	if err != nil {
-		return nil, err
-	}
-
-	c.fromInternal(result.Object, schema)
-
-	return result.Object, nil
-}
-
-func (c *Store) toInternal(data map[string]interface{}, schema *types.Schema) {
-	if schema.Mapper != nil {
-		schema.Mapper.ToInternal(data)
-	}
-}
-
-func (c *Store) fromInternal(data map[string]interface{}, schema *types.Schema) {
-	if schema.Mapper != nil {
-		schema.Mapper.FromInternal(data)
-	}
-
-	data["type"] = schema.ID
-	name, _ := data["name"].(string)
-	namespace, _ := data["namespace"].(string)
-
-	if name != "" {
-		if namespace == "" {
-			data["id"] = name
-		} else {
-			data["id"] = namespace + ":" + name
-		}
-	}
-
-	if status, ok := c.schemaStatus[schema]; ok {
-		if status.Spec.Scope != apiext.NamespaceScoped {
-			delete(data, "namespace")
-		}
-	}
+	return store.ByID(apiContext, schema, id)
 }
 
 func (c *Store) Delete(apiContext *types.APIContext, schema *types.Schema, id string) error {
-	crd, ok := c.schemaStatus[schema]
+	store, ok := c.schemaStores[schema]
 	if !ok {
 		return nil
 	}
-
-	namespace := ""
-	parts := strings.SplitN(id, ":", 2)
-
-	if len(parts) == 2 {
-		namespace = parts[0]
-		id = parts[1]
-	}
-
-	prop := metav1.DeletePropagationForeground
-	req := c.k8sClient.Delete().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural).
-		Body(&metav1.DeleteOptions{
-			PropagationPolicy: &prop,
-		}).
-		Name(id)
-
-	if namespace != "" {
-		req.Namespace(namespace)
-	}
-
-	result := &unstructured.Unstructured{}
-	return req.Do().Into(result)
+	return store.Delete(apiContext, schema, id)
 }
 
-func (c *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) ([]map[string]interface{}, error) {
-	crd, ok := c.schemaStatus[schema]
+func (c *Store) List(apiContext *types.APIContext, schema *types.Schema, opt types.QueryOptions) ([]map[string]interface{}, error) {
+	store, ok := c.schemaStores[schema]
 	if !ok {
 		return nil, nil
 	}
-
-	req := c.k8sClient.Get().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural)
-
-	resultList := &unstructured.UnstructuredList{}
-	err := req.Do().Into(resultList)
-	if err != nil {
-		return nil, err
-	}
-
-	result := []map[string]interface{}{}
-
-	for _, obj := range resultList.Items {
-		c.fromInternal(obj.Object, schema)
-		result = append(result, obj.Object)
-	}
-
-	return result, nil
+	return store.List(apiContext, schema, opt)
 }
 
 func (c *Store) Update(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}, id string) (map[string]interface{}, error) {
-	crd, ok := c.schemaStatus[schema]
+	store, ok := c.schemaStores[schema]
 	if !ok {
 		return nil, nil
 	}
-
-	namespace := ""
-	parts := strings.SplitN(id, ":", 2)
-
-	if len(parts) == 2 {
-		namespace = parts[0]
-		id = parts[1]
-	}
-
-	req := c.k8sClient.Get().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural).
-		Name(id)
-
-	if namespace != "" {
-		req.Namespace(namespace)
-	}
-
-	result := &unstructured.Unstructured{}
-	err := req.Do().Into(result)
-	if err != nil {
-		return nil, err
-	}
-
-	c.fromInternal(result.Object, schema)
-
-	for k, v := range data {
-		if k == "metadata" {
-			continue
-		}
-		result.Object[k] = v
-	}
-
-	c.toInternal(result.Object, schema)
-
-	req = c.k8sClient.Put().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural).
-		Body(result).
-		Name(id)
-
-	if namespace != "" {
-		req.Namespace(namespace)
-	}
-
-	result = &unstructured.Unstructured{}
-	err = req.Do().Into(result)
-	if err != nil {
-		return nil, err
-	}
-
-	c.fromInternal(result.Object, schema)
-	return result.Object, nil
+	return store.Update(apiContext, schema, data, id)
 }
 
 func (c *Store) Create(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}) (map[string]interface{}, error) {
-	crd, ok := c.schemaStatus[schema]
+	store, ok := c.schemaStores[schema]
 	if !ok {
 		return nil, nil
 	}
-
-	namespace, _ := data["namespace"].(string)
-
-	data["apiVersion"] = crd.Spec.Group + "/" + crd.Spec.Version
-	data["kind"] = crd.Status.AcceptedNames.Kind
-
-	c.toInternal(data, schema)
-
-	req := c.k8sClient.Post().
-		Prefix("apis", crd.Spec.Group, crd.Spec.Version).
-		Resource(crd.Status.AcceptedNames.Plural).
-		Body(&unstructured.Unstructured{
-			Object: data,
-		})
-
-	if crd.Spec.Scope == apiext.NamespaceScoped {
-		req.Namespace(namespace)
-	}
-
-	result := &unstructured.Unstructured{}
-	err := req.Do().Into(result)
-	if err != nil {
-		return nil, err
-	}
-
-	c.fromInternal(result.Object, schema)
-	return result.Object, nil
+	return store.Create(apiContext, schema, data)
 }
 
 func (c *Store) AddSchemas(ctx context.Context, schemas *types.Schemas) error {
@@ -252,6 +78,8 @@ func (c *Store) AddSchemas(ctx context.Context, schemas *types.Schemas) error {
 		return schemas.Err()
 	}
 
+	schemaStatus := map[*types.Schema]*apiext.CustomResourceDefinition{}
+
 	for _, schema := range schemas.Schemas() {
 		if schema.Store != nil || !contains(schema.CollectionMethods, http.MethodGet) {
 			continue
@@ -271,7 +99,7 @@ func (c *Store) AddSchemas(ctx context.Context, schemas *types.Schemas) error {
 		if err != nil {
 			return err
 		}
-		c.schemaStatus[schema] = crd
+		schemaStatus[schema] = crd
 	}
 
 	ready, err = c.getReadyCRDs()
@@ -279,14 +107,23 @@ func (c *Store) AddSchemas(ctx context.Context, schemas *types.Schemas) error {
 		return err
 	}
 
-	for schema, crd := range c.schemaStatus {
+	for schema, crd := range schemaStatus {
 		if _, ok := ready[crd.Name]; !ok {
-			if err := c.waitCRD(ctx, crd.Name, schema); err != nil {
+			if err := c.waitCRD(ctx, crd.Name, schema, schemaStatus); err != nil {
 				return err
 			}
 		}
 	}
 
+	for schema, crd := range schemaStatus {
+		c.schemaStores[schema] = proxy.NewProxyStore(c.k8sClient,
+			[]string{"apis"},
+			crd.Spec.Group,
+			crd.Spec.Version,
+			crd.Status.AcceptedNames.Kind,
+			crd.Status.AcceptedNames.Plural)
+	}
+
 	return nil
 }
 
@@ -300,7 +137,7 @@ func contains(list []string, s string) bool {
 	return false
 }
 
-func (c *Store) waitCRD(ctx context.Context, crdName string, schema *types.Schema) error {
+func (c *Store) waitCRD(ctx context.Context, crdName string, schema *types.Schema, schemaStatus map[*types.Schema]*apiext.CustomResourceDefinition) error {
 	logrus.Infof("Waiting for CRD %s to become available", crdName)
 	defer logrus.Infof("Done waiting for CRD %s to become available", crdName)
 
@@ -320,7 +157,7 @@ func (c *Store) waitCRD(ctx context.Context, crdName string, schema *types.Schem
 			switch cond.Type {
 			case apiext.Established:
 				if cond.Status == apiext.ConditionTrue {
-					c.schemaStatus[schema] = crd
+					schemaStatus[schema] = crd
 					return true, err
 				}
 			case apiext.NamesAccepted:
@@ -354,7 +191,7 @@ func (c *Store) createCRD(schema *types.Schema, ready map[string]apiext.CustomRe
 			Scope: apiext.ClusterScoped,
 			Names: apiext.CustomResourceDefinitionNames{
 				Plural: plural,
-				Kind:   capitalize(schema.ID),
+				Kind:   convert.Capitalize(schema.ID),
 			},
 		},
 	}
@@ -388,21 +225,3 @@ func (c *Store) getReadyCRDs() (map[string]apiext.CustomResourceDefinition, erro
 
 	return result, nil
 }
-
-func getScope(schema *types.Schema) apiext.ResourceScope {
-	for name := range schema.ResourceFields {
-		if name == "namespace" {
-			return apiext.NamespaceScoped
-		}
-	}
-
-	return apiext.ClusterScoped
-}
-
-func capitalize(s string) string {
-	if len(s) == 0 {
-		return s
-	}
-
-	return strings.ToUpper(s[0:1]) + s[1:]
-}
diff --git a/store/proxy/proxy_store.go b/store/proxy/proxy_store.go
index 1dd462ded..d1d029221 100644
--- a/store/proxy/proxy_store.go
+++ b/store/proxy/proxy_store.go
@@ -5,13 +5,14 @@ import (
 
 	"github.com/rancher/norman/types"
 	"github.com/rancher/norman/types/convert"
+	"github.com/rancher/norman/types/mapper"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/client-go/rest"
 )
 
 type Store struct {
-	k8sClient      *rest.RESTClient
+	k8sClient      rest.Interface
 	prefix         []string
 	group          string
 	version        string
@@ -19,7 +20,7 @@ type Store struct {
 	resourcePlural string
 }
 
-func NewProxyStore(k8sClient *rest.RESTClient,
+func NewProxyStore(k8sClient rest.Interface,
 	prefix []string, group, version, kind, resourcePlural string) *Store {
 	return &Store{
 		k8sClient:      k8sClient,
@@ -40,7 +41,7 @@ func (p *Store) ByID(apiContext *types.APIContext, schema *types.Schema, id stri
 	return p.singleResult(schema, req)
 }
 
-func (p *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) ([]map[string]interface{}, error) {
+func (p *Store) List(apiContext *types.APIContext, schema *types.Schema, opt types.QueryOptions) ([]map[string]interface{}, error) {
 	namespace := getNamespace(apiContext, opt)
 
 	req := p.common(namespace, p.k8sClient.Get())
@@ -51,7 +52,7 @@ func (p *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *ty
 		return nil, err
 	}
 
-	result := []map[string]interface{}{}
+	var result []map[string]interface{}
 
 	for _, obj := range resultList.Items {
 		result = append(result, p.fromInternal(schema, obj.Object))
@@ -60,18 +61,14 @@ func (p *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *ty
 	return result, nil
 }
 
-func getNamespace(apiContext *types.APIContext, opt *types.QueryOptions) string {
+func getNamespace(apiContext *types.APIContext, opt types.QueryOptions) string {
 	if val, ok := apiContext.SubContext["namespace"]; ok {
 		return convert.ToString(val)
 	}
 
-	if opt == nil {
-		return ""
-	}
-
 	for _, condition := range opt.Conditions {
-		if condition.Field == "namespace" && len(condition.Values) > 0 {
-			return convert.ToString(condition.Values[0])
+		if condition.Field == "namespace" && condition.Value != "" {
+			return condition.Value
 		}
 	}
 
@@ -82,6 +79,14 @@ func (p *Store) Create(apiContext *types.APIContext, schema *types.Schema, data
 	namespace, _ := data["namespace"].(string)
 	p.toInternal(schema.Mapper, data)
 
+	name, _ := mapper.GetValueN(data, "metadata", "name").(string)
+	if name == "" {
+		generated, _ := mapper.GetValueN(data, "metadata", "generateName").(string)
+		if generated == "" {
+			mapper.PutValue(data, schema.ID+"-", "metadata", "generateName")
+		}
+	}
+
 	req := p.common(namespace, p.k8sClient.Post()).
 		Body(&unstructured.Unstructured{
 			Object: data,
@@ -180,17 +185,6 @@ func (p *Store) fromInternal(schema *types.Schema, data map[string]interface{})
 	if schema.Mapper != nil {
 		schema.Mapper.FromInternal(data)
 	}
-	data["type"] = schema.ID
-	name, _ := data["name"].(string)
-	namespace, _ := data["namespace"].(string)
-
-	if name != "" {
-		if namespace == "" {
-			data["id"] = name
-		} else {
-			data["id"] = namespace + ":" + name
-		}
-	}
 
 	return data
 }
diff --git a/store/schema/schema_store.go b/store/schema/schema_store.go
index bd62eaf5e..a4d284ec1 100644
--- a/store/schema/schema_store.go
+++ b/store/schema/schema_store.go
@@ -18,7 +18,7 @@ func NewSchemaStore() types.Store {
 }
 
 func (s *Store) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
-	for _, schema := range apiContext.Schemas.Schemas() {
+	for _, schema := range apiContext.Schemas.SchemasForVersion(*apiContext.Version) {
 		if strings.EqualFold(schema.ID, id) {
 			schemaData := map[string]interface{}{}
 
@@ -33,16 +33,19 @@ func (s *Store) ByID(apiContext *types.APIContext, schema *types.Schema, id stri
 	return nil, nil
 }
 
-func (s *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) ([]map[string]interface{}, error) {
-	schemaData := []map[string]interface{}{}
+func (s *Store) List(apiContext *types.APIContext, schema *types.Schema, opt types.QueryOptions) ([]map[string]interface{}, error) {
+	schemaMap := apiContext.Schemas.SchemasForVersion(*apiContext.Version)
+	schemas := make([]*types.Schema, 0, len(schemaMap))
+	schemaData := make([]map[string]interface{}, 0, len(schemaMap))
 
-	data, err := json.Marshal(apiContext.Schemas.Schemas())
-	if err != nil {
-		return nil, err
+	for _, schema := range schemaMap {
+		schemas = append(schemas, schema)
 	}
 
-	if err := json.Unmarshal(data, &schemaData); err != nil {
+	data, err := json.Marshal(schemas)
+	if err != nil {
 		return nil, err
 	}
-	return schemaData, nil
+
+	return schemaData, json.Unmarshal(data, &schemaData)
 }
diff --git a/store/tranform/transform.go b/store/tranform/transform.go
new file mode 100644
index 000000000..007c04a0f
--- /dev/null
+++ b/store/tranform/transform.go
@@ -0,0 +1,76 @@
+package tranform
+
+import "github.com/rancher/norman/types"
+
+type TransformerFunc func(apiContext *types.APIContext, data map[string]interface{}) (map[string]interface{}, error)
+
+type ListTransformerFunc func(apiContext *types.APIContext, data []map[string]interface{}) ([]map[string]interface{}, error)
+
+type TransformingStore struct {
+	Store           types.Store
+	Transformer     TransformerFunc
+	ListTransformer ListTransformerFunc
+}
+
+func (t *TransformingStore) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
+	data, err := t.Store.ByID(apiContext, schema, id)
+	if err != nil {
+		return nil, err
+	}
+	if t.Transformer == nil {
+		return data, nil
+	}
+	return t.Transformer(apiContext, data)
+}
+
+func (t *TransformingStore) List(apiContext *types.APIContext, schema *types.Schema, opt types.QueryOptions) ([]map[string]interface{}, error) {
+	data, err := t.Store.List(apiContext, schema, opt)
+	if err != nil {
+		return nil, err
+	}
+
+	if t.ListTransformer != nil {
+		return t.ListTransformer(apiContext, data)
+	}
+
+	if t.Transformer == nil {
+		return data, nil
+	}
+
+	var result []map[string]interface{}
+	for _, item := range data {
+		item, err := t.Transformer(apiContext, item)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+
+	return result, nil
+}
+
+func (t *TransformingStore) Create(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}) (map[string]interface{}, error) {
+	data, err := t.Store.Create(apiContext, schema, data)
+	if err != nil {
+		return nil, err
+	}
+	if t.Transformer == nil {
+		return data, nil
+	}
+	return t.Transformer(apiContext, data)
+}
+
+func (t *TransformingStore) Update(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}, id string) (map[string]interface{}, error) {
+	data, err := t.Store.Update(apiContext, schema, data, id)
+	if err != nil {
+		return nil, err
+	}
+	if t.Transformer == nil {
+		return data, nil
+	}
+	return t.Transformer(apiContext, data)
+}
+
+func (t *TransformingStore) Delete(apiContext *types.APIContext, schema *types.Schema, id string) error {
+	return t.Store.Delete(apiContext, schema, id)
+}
diff --git a/store/wrapper/wrapper.go b/store/wrapper/wrapper.go
new file mode 100644
index 000000000..9a809ba38
--- /dev/null
+++ b/store/wrapper/wrapper.go
@@ -0,0 +1,97 @@
+package wrapper
+
+import (
+	"github.com/rancher/norman/httperror"
+	"github.com/rancher/norman/types"
+)
+
+func Wrap(store types.Store) types.Store {
+	return &StoreWrapper{
+		store: store,
+	}
+}
+
+type StoreWrapper struct {
+	store types.Store
+}
+
+func (s *StoreWrapper) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
+	data, err := s.store.ByID(apiContext, schema, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return apiContext.FilterObject(types.QueryOptions{
+		Conditions: apiContext.SubContextAttributeProvider.Query(apiContext, schema),
+	}, data), nil
+}
+
+func (s *StoreWrapper) List(apiContext *types.APIContext, schema *types.Schema, opts types.QueryOptions) ([]map[string]interface{}, error) {
+	opts.Conditions = append(opts.Conditions, apiContext.SubContextAttributeProvider.Query(apiContext, schema)...)
+	data, err := s.store.List(apiContext, schema, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return apiContext.FilterList(opts, data), nil
+}
+
+func (s *StoreWrapper) Create(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}) (map[string]interface{}, error) {
+	for key, value := range apiContext.SubContextAttributeProvider.Create(apiContext, schema) {
+		if data == nil {
+			data = map[string]interface{}{}
+		}
+		data[key] = value
+	}
+
+	data, err := s.store.Create(apiContext, schema, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (s *StoreWrapper) Update(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}, id string) (map[string]interface{}, error) {
+	err := validateGet(apiContext, schema, id)
+	if err != nil {
+		return nil, err
+	}
+
+	data, err = s.store.Update(apiContext, schema, data, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return apiContext.FilterObject(types.QueryOptions{
+		Conditions: apiContext.SubContextAttributeProvider.Query(apiContext, schema),
+	}, data), nil
+}
+
+func (s *StoreWrapper) Delete(apiContext *types.APIContext, schema *types.Schema, id string) error {
+	if err := validateGet(apiContext, schema, id); err != nil {
+		return err
+	}
+
+	return s.store.Delete(apiContext, schema, id)
+}
+
+func validateGet(apiContext *types.APIContext, schema *types.Schema, id string) error {
+	store := schema.Store
+	if store == nil {
+		return nil
+	}
+
+	existing, err := store.ByID(apiContext, schema, id)
+	if err != nil {
+		return err
+	}
+
+	if apiContext.Filter(types.QueryOptions{
+		Conditions: apiContext.SubContextAttributeProvider.Query(apiContext, schema),
+	}, existing) == nil {
+		return httperror.NewAPIError(httperror.NotFound, "failed to find "+id)
+	}
+
+	return nil
+}
diff --git a/types/condition.go b/types/condition.go
index 0d5bdd07c..aebe36e4a 100644
--- a/types/condition.go
+++ b/types/condition.go
@@ -1,108 +1,108 @@
 package types
 
-var (
-	COND_EQ      = QueryConditionType{"eq", 1}
-	COND_NE      = QueryConditionType{"ne", 1}
-	COND_NULL    = QueryConditionType{"null", 0}
-	COND_NOTNULL = QueryConditionType{"notnull", 0}
-	COND_IN      = QueryConditionType{"in", -1}
-	COND_NOTIN   = QueryConditionType{"notin", -1}
-	COND_OR      = QueryConditionType{"or", 1}
-	COND_AND     = QueryConditionType{"and", 1}
+import (
+	"github.com/rancher/norman/types/convert"
+)
 
-	mods = map[string]QueryConditionType{
-		COND_EQ.Name:      COND_EQ,
-		COND_NE.Name:      COND_NE,
-		COND_NULL.Name:    COND_NULL,
-		COND_NOTNULL.Name: COND_NOTNULL,
-		COND_IN.Name:      COND_IN,
-		COND_NOTIN.Name:   COND_NOTIN,
-		COND_OR.Name:      COND_OR,
-		COND_AND.Name:     COND_AND,
+var (
+	CondEQ      = QueryConditionType{ModifierEQ, 1}
+	CondNE      = QueryConditionType{ModifierNE, 1}
+	CondNull    = QueryConditionType{ModifierNull, 0}
+	CondNotNull = QueryConditionType{ModifierNotNull, 0}
+	CondIn      = QueryConditionType{ModifierIn, -1}
+	CondNotIn   = QueryConditionType{ModifierNotIn, -1}
+	CondOr      = QueryConditionType{ModifierType("or"), 1}
+	CondAnd     = QueryConditionType{ModifierType("and"), 1}
+
+	mods = map[ModifierType]QueryConditionType{
+		CondEQ.Name:      CondEQ,
+		CondNE.Name:      CondNE,
+		CondNull.Name:    CondNull,
+		CondNotNull.Name: CondNotNull,
+		CondIn.Name:      CondIn,
+		CondNotIn.Name:   CondNotIn,
+		CondOr.Name:      CondOr,
+		CondAnd.Name:     CondAnd,
 	}
 )
 
 type QueryConditionType struct {
-	Name string
+	Name ModifierType
 	Args int
 }
 
 type QueryCondition struct {
 	Field         string
-	Values        []interface{}
+	Value         string
+	Values        map[string]bool
 	conditionType QueryConditionType
 	left, right   *QueryCondition
 }
 
+func (q *QueryCondition) Valid(data map[string]interface{}) bool {
+	switch q.conditionType {
+	case CondAnd:
+		if q.left == nil || q.right == nil {
+			return false
+		}
+		return q.left.Valid(data) && q.right.Valid(data)
+	case CondOr:
+		if q.left == nil || q.right == nil {
+			return false
+		}
+		return q.left.Valid(data) || q.right.Valid(data)
+	case CondEQ:
+		return q.Value == convert.ToString(data[q.Field])
+	case CondNE:
+		return q.Value != convert.ToString(data[q.Field])
+	case CondIn:
+		return q.Values[convert.ToString(data[q.Field])]
+	case CondNotIn:
+		return !q.Values[convert.ToString(data[q.Field])]
+	case CondNotNull:
+		return convert.ToString(data[q.Field]) != ""
+	case CondNull:
+		return convert.ToString(data[q.Field]) == ""
+	}
+
+	return false
+}
+
 func (q *QueryCondition) ToCondition() Condition {
 	cond := Condition{
 		Modifier: q.conditionType.Name,
 	}
-	if q.conditionType.Args == 1 && len(q.Values) > 0 {
-		cond.Value = q.Values[0]
+	if q.conditionType.Args == 1 {
+		cond.Value = q.Value
 	} else if q.conditionType.Args == -1 {
-		cond.Value = q.Values
+		stringValues := []string{}
+		for val := range q.Values {
+			stringValues = append(stringValues, val)
+		}
+		cond.Value = stringValues
 	}
 
 	return cond
 }
 
-func ValidMod(mod string) bool {
+func ValidMod(mod ModifierType) bool {
 	_, ok := mods[mod]
 	return ok
 }
 
-func NewConditionFromString(field, mod string, values ...interface{}) *QueryCondition {
-	return &QueryCondition{
+func NewConditionFromString(field string, mod ModifierType, values ...string) *QueryCondition {
+	q := &QueryCondition{
 		Field:         field,
-		Values:        values,
 		conditionType: mods[mod],
+		Values:        map[string]bool{},
 	}
-}
 
-func NewCondition(mod QueryConditionType, values ...interface{}) *QueryCondition {
-	return &QueryCondition{
-		Values:        values,
-		conditionType: mod,
+	for i, value := range values {
+		if i == 0 {
+			q.Value = value
+		}
+		q.Values[value] = true
 	}
-}
-
-func NE(value interface{}) *QueryCondition {
-	return NewCondition(COND_NE, value)
-}
-
-func EQ(value interface{}) *QueryCondition {
-	return NewCondition(COND_EQ, value)
-}
 
-func NULL(value interface{}) *QueryCondition {
-	return NewCondition(COND_NULL)
-}
-
-func NOTNULL(value interface{}) *QueryCondition {
-	return NewCondition(COND_NOTNULL)
-}
-
-func IN(values ...interface{}) *QueryCondition {
-	return NewCondition(COND_IN, values...)
-}
-
-func NOTIN(values ...interface{}) *QueryCondition {
-	return NewCondition(COND_NOTIN, values...)
-}
-
-func (c *QueryCondition) AND(right *QueryCondition) *QueryCondition {
-	return &QueryCondition{
-		conditionType: COND_AND,
-		left:          c,
-		right:         right,
-	}
-}
-
-func (c *QueryCondition) OR(right *QueryCondition) *QueryCondition {
-	return &QueryCondition{
-		conditionType: COND_OR,
-		left:          c,
-		right:         right,
-	}
+	return q
 }
diff --git a/types/convert/convert.go b/types/convert/convert.go
index 1e585bc56..421d7aedf 100644
--- a/types/convert/convert.go
+++ b/types/convert/convert.go
@@ -132,12 +132,12 @@ func ToStringSlice(data interface{}) []string {
 	return nil
 }
 
-func ToObj(data interface{}, obj interface{}) error {
+func ToObj(data interface{}, into interface{}) error {
 	bytes, err := json.Marshal(data)
 	if err != nil {
 		return err
 	}
-	return json.Unmarshal(bytes, obj)
+	return json.Unmarshal(bytes, into)
 }
 
 func EncodeToMap(obj interface{}) (map[string]interface{}, error) {
diff --git a/types/convert/ref.go b/types/convert/ref.go
new file mode 100644
index 000000000..b269a76cd
--- /dev/null
+++ b/types/convert/ref.go
@@ -0,0 +1,11 @@
+package convert
+
+import "fmt"
+
+func ToReference(typeName string) string {
+	return fmt.Sprintf("reference[%s]", typeName)
+}
+
+func ToFullReference(path, typeName string) string {
+	return fmt.Sprintf("reference[%s/schemas/%s]", path, typeName)
+}
diff --git a/types/convert/value_set_string.go b/types/convert/value_set_string.go
index 88f981d39..d9b329fa0 100644
--- a/types/convert/value_set_string.go
+++ b/types/convert/value_set_string.go
@@ -13,7 +13,6 @@ func ToValuesSlice(value string) []string {
 	value = strings.TrimSpace(value)
 	if strings.HasPrefix(value, "(") && strings.HasSuffix(value, ")") {
 		return splitRegexp.Split(value[1:len(value)-1], -1)
-	} else {
-		return []string{value}
 	}
+	return []string{value}
 }
diff --git a/types/factory/schemas.go b/types/factory/schemas.go
new file mode 100644
index 000000000..055daee01
--- /dev/null
+++ b/types/factory/schemas.go
@@ -0,0 +1,19 @@
+package factory
+
+import (
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/mapper"
+	"k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func Schemas(version *types.APIVersion) *types.Schemas {
+	s := types.NewSchemas()
+	s.DefaultMappers = []types.Mapper{
+		mapper.NewObject(),
+	}
+	s.DefaultPostMappers = []types.Mapper{
+		&mapper.RenameReference{},
+	}
+	s.AddMapperForType(version, v1.ObjectMeta{}, mapper.NewMetadataMapper())
+	return s
+}
diff --git a/types/mapper.go b/types/mapper.go
index 0b43e6c04..3bd858783 100644
--- a/types/mapper.go
+++ b/types/mapper.go
@@ -1,7 +1,6 @@
 package types
 
 import (
-	"github.com/pkg/errors"
 	"github.com/rancher/norman/types/definition"
 )
 
@@ -11,14 +10,37 @@ type Mapper interface {
 	ModifySchema(schema *Schema, schemas *Schemas) error
 }
 
-type TypeMapper struct {
+type Mappers []Mapper
+
+func (m Mappers) FromInternal(data map[string]interface{}) {
+	for _, mapper := range m {
+		mapper.FromInternal(data)
+	}
+}
+
+func (m Mappers) ToInternal(data map[string]interface{}) {
+	for i := len(m) - 1; i >= 0; i-- {
+		m[i].ToInternal(data)
+	}
+}
+
+func (m Mappers) ModifySchema(schema *Schema, schemas *Schemas) error {
+	for _, mapper := range m {
+		if err := mapper.ModifySchema(schema, schemas); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type typeMapper struct {
 	Mappers         []Mapper
 	typeName        string
 	subSchemas      map[string]*Schema
 	subArraySchemas map[string]*Schema
 }
 
-func (t *TypeMapper) FromInternal(data map[string]interface{}) {
+func (t *typeMapper) FromInternal(data map[string]interface{}) {
 	for fieldName, schema := range t.subSchemas {
 		if schema.Mapper == nil {
 			continue
@@ -38,19 +60,29 @@ func (t *TypeMapper) FromInternal(data map[string]interface{}) {
 		}
 	}
 
-	for _, mapper := range t.Mappers {
-		mapper.FromInternal(data)
-	}
+	Mappers(t.Mappers).FromInternal(data)
 
 	if data != nil {
-		data["type"] = t.typeName
+		if _, ok := data["type"]; !ok {
+			data["type"] = t.typeName
+		}
+		name, _ := data["name"].(string)
+		namespace, _ := data["namespace"].(string)
+
+		if _, ok := data["id"]; !ok {
+			if name != "" {
+				if namespace == "" {
+					data["id"] = name
+				} else {
+					data["id"] = namespace + ":" + name
+				}
+			}
+		}
 	}
 }
 
-func (t *TypeMapper) ToInternal(data map[string]interface{}) {
-	for i := len(t.Mappers) - 1; i >= 0; i-- {
-		t.Mappers[i].ToInternal(data)
-	}
+func (t *typeMapper) ToInternal(data map[string]interface{}) {
+	Mappers(t.Mappers).ToInternal(data)
 
 	for fieldName, schema := range t.subArraySchemas {
 		if schema.Mapper == nil {
@@ -71,7 +103,7 @@ func (t *TypeMapper) ToInternal(data map[string]interface{}) {
 	}
 }
 
-func (t *TypeMapper) ModifySchema(schema *Schema, schemas *Schemas) error {
+func (t *typeMapper) ModifySchema(schema *Schema, schemas *Schemas) error {
 	t.subSchemas = map[string]*Schema{}
 	t.subArraySchemas = map[string]*Schema{}
 	t.typeName = schema.ID
@@ -94,11 +126,5 @@ func (t *TypeMapper) ModifySchema(schema *Schema, schemas *Schemas) error {
 		}
 	}
 
-	for _, mapper := range t.Mappers {
-		if err := mapper.ModifySchema(schema, schemas); err != nil {
-			return errors.Wrapf(err, "mapping type %s", schema.ID)
-		}
-	}
-
-	return nil
+	return Mappers(t.Mappers).ModifySchema(schema, schemas)
 }
diff --git a/types/mapper/access.go b/types/mapper/access.go
new file mode 100644
index 000000000..14043c589
--- /dev/null
+++ b/types/mapper/access.go
@@ -0,0 +1,33 @@
+package mapper
+
+import (
+	"strings"
+
+	"github.com/rancher/norman/types"
+)
+
+type Access struct {
+	Fields map[string]string
+}
+
+func (e Access) FromInternal(data map[string]interface{}) {
+}
+
+func (e Access) ToInternal(data map[string]interface{}) {
+}
+
+func (e Access) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	for name, access := range e.Fields {
+		if err := validateField(name, schema); err != nil {
+			return err
+		}
+
+		field := schema.ResourceFields[name]
+		field.Create = strings.Contains(access, "c")
+		field.Update = strings.Contains(access, "u")
+		field.WriteOnly = strings.Contains(access, "o")
+
+		schema.ResourceFields[name] = field
+	}
+	return nil
+}
diff --git a/types/mapper/check.go b/types/mapper/check.go
new file mode 100644
index 000000000..30e7cefae
--- /dev/null
+++ b/types/mapper/check.go
@@ -0,0 +1,15 @@
+package mapper
+
+import (
+	"fmt"
+
+	"github.com/rancher/norman/types"
+)
+
+func validateField(field string, schema *types.Schema) error {
+	if _, ok := schema.ResourceFields[field]; !ok {
+		return fmt.Errorf("field %s missing on schema %s", field, schema.ID)
+	}
+
+	return nil
+}
diff --git a/types/mapper/display_name.go b/types/mapper/display_name.go
new file mode 100644
index 000000000..506aff169
--- /dev/null
+++ b/types/mapper/display_name.go
@@ -0,0 +1,28 @@
+package mapper
+
+import (
+	"github.com/rancher/norman/types"
+)
+
+var displayNameMappers = types.Mappers{
+	&Move{From: "name", To: "id"},
+	&Move{From: "displayName", To: "name"},
+	Access{Fields: map[string]string{
+		"id": "",
+	}},
+}
+
+type DisplayName struct {
+}
+
+func (d DisplayName) FromInternal(data map[string]interface{}) {
+	displayNameMappers.FromInternal(data)
+}
+
+func (d DisplayName) ToInternal(data map[string]interface{}) {
+	displayNameMappers.ToInternal(data)
+}
+
+func (d DisplayName) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	return displayNameMappers.ModifySchema(schema, schemas)
+}
diff --git a/types/mapping/mapper/drop.go b/types/mapper/drop.go
similarity index 88%
rename from types/mapping/mapper/drop.go
rename to types/mapper/drop.go
index a76d9ac5a..64032d8fc 100644
--- a/types/mapping/mapper/drop.go
+++ b/types/mapper/drop.go
@@ -18,11 +18,6 @@ func (d Drop) ToInternal(data map[string]interface{}) {
 }
 
 func (d Drop) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
-	_, err := getInternal(schema)
-	if err != nil {
-		return err
-	}
-
 	if _, ok := schema.ResourceFields[d.Field]; !ok {
 		return fmt.Errorf("can not drop missing field %s on %s", d.Field, schema.ID)
 	}
diff --git a/types/mapping/mapper/embed.go b/types/mapper/embed.go
similarity index 85%
rename from types/mapping/mapper/embed.go
rename to types/mapper/embed.go
index ea5c3e800..2c48945b5 100644
--- a/types/mapping/mapper/embed.go
+++ b/types/mapper/embed.go
@@ -8,7 +8,9 @@ import (
 
 type Embed struct {
 	Field          string
+	Optional       bool
 	ReadOnly       bool
+	Ignore         []string
 	ignoreOverride bool
 	embeddedFields []string
 }
@@ -37,20 +39,29 @@ func (e *Embed) ToInternal(data map[string]interface{}) {
 }
 
 func (e *Embed) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
-	internalSchema, err := validateInternalField(e.Field, schema)
+	err := validateField(e.Field, schema)
 	if err != nil {
+		if e.Optional {
+			return nil
+		}
 		return err
 	}
 
 	e.embeddedFields = []string{}
 
-	embeddedSchemaID := internalSchema.ResourceFields[e.Field].Type
+	embeddedSchemaID := schema.ResourceFields[e.Field].Type
 	embeddedSchema := schemas.Schema(&schema.Version, embeddedSchemaID)
 	if embeddedSchema == nil {
 		return fmt.Errorf("failed to find schema %s for embedding", embeddedSchemaID)
 	}
 
 	for name, field := range embeddedSchema.ResourceFields {
+		for _, ignore := range e.Ignore {
+			if ignore == name {
+				continue
+			}
+		}
+
 		if !e.ignoreOverride {
 			if _, ok := schema.ResourceFields[name]; ok {
 				return fmt.Errorf("embedding field %s on %s will overwrite the field %s",
diff --git a/types/mapping/mapper/enum.go b/types/mapper/enum.go
similarity index 92%
rename from types/mapping/mapper/enum.go
rename to types/mapper/enum.go
index e2c276e3e..96d2e69f5 100644
--- a/types/mapping/mapper/enum.go
+++ b/types/mapper/enum.go
@@ -44,6 +44,5 @@ func (e Enum) ToInternal(data map[string]interface{}) {
 }
 
 func (e Enum) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
-	_, err := validateInternalField(e.Field, schema)
-	return err
+	return validateField(e.Field, schema)
 }
diff --git a/types/mapper/label_field.go b/types/mapper/label_field.go
new file mode 100644
index 000000000..6a05d57ac
--- /dev/null
+++ b/types/mapper/label_field.go
@@ -0,0 +1,25 @@
+package mapper
+
+import "github.com/rancher/norman/types"
+
+type LabelField struct {
+	Field string
+}
+
+func (e LabelField) FromInternal(data map[string]interface{}) {
+	v, ok := RemoveValue(data, "labels", "io.cattle.field."+e.Field)
+	if ok {
+		data[e.Field] = v
+	}
+}
+
+func (e LabelField) ToInternal(data map[string]interface{}) {
+	v, ok := data[e.Field]
+	if ok {
+		PutValue(data, v, "labels", "io.cattle.field."+e.Field)
+	}
+}
+
+func (e LabelField) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	return validateField(e.Field, schema)
+}
diff --git a/types/mapper/metadata.go b/types/mapper/metadata.go
new file mode 100644
index 000000000..ddbfa5f8e
--- /dev/null
+++ b/types/mapper/metadata.go
@@ -0,0 +1,30 @@
+package mapper
+
+import (
+	"github.com/rancher/norman/types"
+)
+
+func NewMetadataMapper() types.Mapper {
+	return types.Mappers{
+		Drop{"generateName"},
+		Move{From: "selfLink", To: "resourcePath"},
+		Move{From: "uid", To: "uuid"},
+		Drop{"resourceVersion"},
+		Drop{"generation"},
+		Move{From: "creationTimestamp", To: "created"},
+		Move{From: "deletionTimestamp", To: "removed"},
+		Drop{"deletionGracePeriodSeconds"},
+		Drop{"initializers"},
+		Drop{"finalizers"},
+		Drop{"clusterName"},
+		ReadOnly{Field: "*"},
+		Access{
+			Fields: map[string]string{
+				"name":        "c",
+				"namespace":   "cu",
+				"labels":      "cu",
+				"annotations": "cu",
+			},
+		},
+	}
+}
diff --git a/types/mapping/mapper/move.go b/types/mapper/move.go
similarity index 93%
rename from types/mapping/mapper/move.go
rename to types/mapper/move.go
index 607f9499b..e39d361d7 100644
--- a/types/mapping/mapper/move.go
+++ b/types/mapper/move.go
@@ -36,7 +36,7 @@ func (m Move) ModifySchema(s *types.Schema, schemas *types.Schemas) error {
 		return fmt.Errorf("failed to find field %s on schema %s", m.From, s.ID)
 	}
 
-	toSchema, toFieldName, toField, ok, err := getField(s, schemas, m.To)
+	toSchema, toFieldName, _, ok, err := getField(s, schemas, m.To)
 	if err != nil {
 		return err
 	}
@@ -50,7 +50,7 @@ func (m Move) ModifySchema(s *types.Schema, schemas *types.Schemas) error {
 	}
 
 	if !m.DestDefined {
-		toField.CodeName = convert.Capitalize(toFieldName)
+		fromField.CodeName = convert.Capitalize(toFieldName)
 		toSchema.ResourceFields[toFieldName] = fromField
 	}
 
diff --git a/types/mapper/object.go b/types/mapper/object.go
new file mode 100644
index 000000000..213295742
--- /dev/null
+++ b/types/mapper/object.go
@@ -0,0 +1,25 @@
+package mapper
+
+import "github.com/rancher/norman/types"
+
+type Object struct {
+	types.Mappers
+}
+
+func NewObject(mappers ...types.Mapper) Object {
+	return Object{
+		Mappers: append([]types.Mapper{
+			&Embed{Field: "metadata"},
+			&Embed{Field: "spec", Optional: true},
+			&ReadOnly{Field: "status", Optional: true},
+			&Drop{"kind"},
+			&Drop{"apiVersion"},
+			&Scope{
+				IfNot: types.NamespaceScope,
+				Mappers: []types.Mapper{
+					&Drop{"namespace"},
+				},
+			},
+		}, mappers...),
+	}
+}
diff --git a/types/mapper/read_only.go b/types/mapper/read_only.go
new file mode 100644
index 000000000..71054496a
--- /dev/null
+++ b/types/mapper/read_only.go
@@ -0,0 +1,41 @@
+package mapper
+
+import (
+	"github.com/rancher/norman/types"
+)
+
+type ReadOnly struct {
+	Field    string
+	Optional bool
+}
+
+func (r ReadOnly) FromInternal(data map[string]interface{}) {
+}
+
+func (r ReadOnly) ToInternal(data map[string]interface{}) {
+}
+
+func (r ReadOnly) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	if r.Field == "*" {
+		for name, field := range schema.ResourceFields {
+			field.Create = false
+			field.Update = false
+			schema.ResourceFields[name] = field
+		}
+		return nil
+	}
+
+	if err := validateField(r.Field, schema); err != nil {
+		if r.Optional {
+			return nil
+		}
+		return err
+	}
+
+	field := schema.ResourceFields[r.Field]
+	field.Create = false
+	field.Update = false
+	schema.ResourceFields[r.Field] = field
+
+	return nil
+}
diff --git a/types/mapper/rename_reference.go b/types/mapper/rename_reference.go
new file mode 100644
index 000000000..d9cd4067a
--- /dev/null
+++ b/types/mapper/rename_reference.go
@@ -0,0 +1,45 @@
+package mapper
+
+import (
+	"strings"
+
+	"github.com/rancher/norman/types"
+	"github.com/rancher/norman/types/definition"
+)
+
+type RenameReference struct {
+	mapper types.Mapper
+}
+
+func (r *RenameReference) FromInternal(data map[string]interface{}) {
+	if r.mapper != nil {
+		r.mapper.FromInternal(data)
+	}
+}
+
+func (r *RenameReference) ToInternal(data map[string]interface{}) {
+	if r.mapper != nil {
+		r.mapper.ToInternal(data)
+	}
+}
+
+func (r *RenameReference) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	var mappers []types.Mapper
+	for name, field := range schema.ResourceFields {
+		if definition.IsReferenceType(field.Type) && strings.HasSuffix(name, "Name") {
+			newName := strings.TrimSuffix(name, "Name") + "Id"
+			move := Move{From: name, To: newName}
+			if err := move.ModifySchema(schema, schemas); err != nil {
+				return err
+			}
+
+			mappers = append(mappers, move)
+		}
+	}
+
+	if len(mappers) > 0 {
+		r.mapper = types.Mappers(mappers)
+	}
+
+	return nil
+}
diff --git a/types/mapper/scope.go b/types/mapper/scope.go
new file mode 100644
index 000000000..fcb596943
--- /dev/null
+++ b/types/mapper/scope.go
@@ -0,0 +1,37 @@
+package mapper
+
+import (
+	"github.com/rancher/norman/types"
+)
+
+type Scope struct {
+	If      types.TypeScope
+	IfNot   types.TypeScope
+	Mappers []types.Mapper
+	run     bool
+}
+
+func (s *Scope) FromInternal(data map[string]interface{}) {
+	if s.run {
+		types.Mappers(s.Mappers).FromInternal(data)
+	}
+}
+
+func (s *Scope) ToInternal(data map[string]interface{}) {
+	if s.run {
+		types.Mappers(s.Mappers).ToInternal(data)
+	}
+}
+
+func (s *Scope) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
+	if s.If != "" {
+		s.run = schema.Scope == s.If
+	}
+	if s.IfNot != "" {
+		s.run = schema.Scope != s.IfNot
+	}
+	if s.run {
+		return types.Mappers(s.Mappers).ModifySchema(schema, schemas)
+	}
+	return nil
+}
diff --git a/types/mapping/mapper/set_value.go b/types/mapper/set_value.go
similarity index 100%
rename from types/mapping/mapper/set_value.go
rename to types/mapper/set_value.go
diff --git a/types/mapping/mapper/slice_to_map.go b/types/mapper/slice_to_map.go
similarity index 83%
rename from types/mapping/mapper/slice_to_map.go
rename to types/mapper/slice_to_map.go
index 1b94449c9..b42d1e5c7 100644
--- a/types/mapping/mapper/slice_to_map.go
+++ b/types/mapper/slice_to_map.go
@@ -31,7 +31,7 @@ func (s SliceToMap) FromInternal(data map[string]interface{}) {
 
 func (s SliceToMap) ToInternal(data map[string]interface{}) {
 	datas, _ := data[s.Field].(map[string]interface{})
-	result := []map[string]interface{}{}
+	var result []map[string]interface{}
 
 	for name, item := range datas {
 		mapItem, _ := item.(map[string]interface{})
@@ -47,14 +47,14 @@ func (s SliceToMap) ToInternal(data map[string]interface{}) {
 }
 
 func (s SliceToMap) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
-	internalSchema, err := validateInternalField(s.Field, schema)
+	err := validateField(s.Field, schema)
 	if err != nil {
 		return err
 	}
 
-	field := internalSchema.ResourceFields[s.Field]
+	field := schema.ResourceFields[s.Field]
 	if !definition.IsArrayType(field.Type) {
-		return fmt.Errorf("field %s on %s is not an array", s.Field, internalSchema.ID)
+		return fmt.Errorf("field %s on %s is not an array", s.Field, schema.ID)
 	}
 
 	field.Type = "map[" + definition.SubType(field.Type) + "]"
diff --git a/types/mapping/mapper/union_embed.go b/types/mapper/union_embed.go
similarity index 100%
rename from types/mapping/mapper/union_embed.go
rename to types/mapper/union_embed.go
diff --git a/types/mapping/mapper/values.go b/types/mapper/values.go
similarity index 92%
rename from types/mapping/mapper/values.go
rename to types/mapper/values.go
index f19b002d3..41cdaba55 100644
--- a/types/mapping/mapper/values.go
+++ b/types/mapper/values.go
@@ -6,9 +6,8 @@ func RemoveValue(data map[string]interface{}, keys ...string) (interface{}, bool
 			val, ok := data[key]
 			delete(data, key)
 			return val, ok
-		} else {
-			data, _ = data[key].(map[string]interface{})
 		}
+		data, _ = data[key].(map[string]interface{})
 	}
 
 	return nil, false
@@ -51,9 +50,8 @@ func GetValue(data map[string]interface{}, keys ...string) (interface{}, bool) {
 		if i == len(keys)-1 {
 			val, ok := data[key]
 			return val, ok
-		} else {
-			data, _ = data[key].(map[string]interface{})
 		}
+		data, _ = data[key].(map[string]interface{})
 	}
 
 	return nil, false
diff --git a/types/mapping/mapper.go b/types/mapping/mapper.go
deleted file mode 100644
index cff512160..000000000
--- a/types/mapping/mapper.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package mapping
-
-var (
-//Metadata m.Mapper = m.CombinedMapper{
-//	Mappers: []m.Mapper{
-//		m.Enum{
-//			From: "name",
-//			To:   "metadata/name",
-//		},
-//		m.Enum{
-//			From: "uuid",
-//			To:   "metadata/uid",
-//		},
-//		m.Enum{
-//			From: "resourceVersion",
-//			To:   "metadata/resourceVersion",
-//		},
-//		m.Enum{
-//			From: "created",
-//			To:   "metadata/creationTimestamp",
-//		},
-//		m.Enum{
-//			From: "removed",
-//			To:   "metadata/deletionTimestamp",
-//		},
-//		m.Enum{
-//			From: "namespace",
-//			To:   "metadata/namespace",
-//		},
-//		m.Enum{
-//			From: "labels",
-//			To:   "metadata/labels",
-//		},
-//		m.Enum{
-//			From: "annotations",
-//			To:   "metadata/annotations",
-//		},
-//		m.Swap{
-//			Left:  "type",
-//			Right: "kind",
-//		},
-//		m.LabelField{
-//			Fields: []string{
-//				"description",
-//			},
-//		},
-//	},
-//}
-)
diff --git a/types/mapping/mapper/check.go b/types/mapping/mapper/check.go
deleted file mode 100644
index 58993615f..000000000
--- a/types/mapping/mapper/check.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package mapper
-
-import (
-	"fmt"
-
-	"github.com/rancher/norman/types"
-)
-
-func getInternal(schema *types.Schema) (*types.Schema, error) {
-	if schema.InternalSchema == nil {
-		return nil, fmt.Errorf("no internal schema found for schema %s", schema.ID)
-	}
-
-	return schema.InternalSchema, nil
-}
-
-func validateInternalField(field string, schema *types.Schema) (*types.Schema, error) {
-	internalSchema, err := getInternal(schema)
-	if err != nil {
-		return nil, err
-	}
-
-	if _, ok := internalSchema.ResourceFields[field]; !ok {
-		return nil, fmt.Errorf("field %s missing on internal schema %s", field, schema.ID)
-	}
-
-	return internalSchema, nil
-}
diff --git a/types/mapping/mapper/copy.go b/types/mapping/mapper/copy.go
deleted file mode 100644
index 45baab24b..000000000
--- a/types/mapping/mapper/copy.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package mapper
-
-import "strings"
-
-type Copy struct {
-	From, To string
-}
-
-func (c Copy) Forward(data map[string]interface{}) {
-	val, ok := GetValue(data, strings.Split(c.From, "/")...)
-	if !ok {
-		return
-	}
-
-	PutValue(data, val, strings.Split(c.To, "/")...)
-}
-
-func (c Copy) Back(data map[string]interface{}) {
-	val, ok := GetValue(data, strings.Split(c.To, "/")...)
-	if !ok {
-		return
-	}
-
-	PutValue(data, val, strings.Split(c.From, "/")...)
-}
diff --git a/types/mapping/mapper/label_field.go b/types/mapping/mapper/label_field.go
deleted file mode 100644
index 5a0babf90..000000000
--- a/types/mapping/mapper/label_field.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package mapper
-
-//type LabelField struct {
-//	Fields []string
-//}
-//
-//func (l LabelField) Forward(data map[string]interface{}) {
-//	for _, field := range l.Fields {
-//		moveForLabel(field).Forward(data)
-//	}
-//
-//}
-//
-//func (l LabelField) Back(data map[string]interface{}) {
-//	for _, field := range l.Fields {
-//		moveForLabel(field).Back(data)
-//	}
-//}
-//
-//func moveForLabel(field string) *Enum {
-//	return &Enum{
-//		From: field,
-//		To:   "metadata/labels/io.cattle.field." + strings.ToLower(field),
-//	}
-//}
diff --git a/types/mapping/mapper/object.go b/types/mapping/mapper/object.go
deleted file mode 100644
index afb0a366c..000000000
--- a/types/mapping/mapper/object.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package mapper
-
-import "github.com/rancher/norman/types"
-
-type Object struct {
-	types.TypeMapper
-}
-
-func NewObject(mappers ...types.Mapper) *Object {
-	return &Object{
-		TypeMapper: types.TypeMapper{
-			Mappers: append([]types.Mapper{
-				&Embed{Field: "metadata"},
-				&Embed{Field: "spec"},
-				&ReadOnly{"status"},
-			}, mappers...),
-		},
-	}
-}
diff --git a/types/mapping/mapper/read_only.go b/types/mapping/mapper/read_only.go
deleted file mode 100644
index 8e5056e61..000000000
--- a/types/mapping/mapper/read_only.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package mapper
-
-import (
-	"fmt"
-
-	"github.com/rancher/norman/types"
-)
-
-type ReadOnly struct {
-	Field string
-}
-
-func (r *ReadOnly) FromInternal(data map[string]interface{}) {
-}
-
-func (r *ReadOnly) ToInternal(data map[string]interface{}) {
-}
-
-func (r *ReadOnly) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
-	field, ok := schema.ResourceFields[r.Field]
-	if !ok {
-		return fmt.Errorf("failed to find field %s on schema %s", r.Field, schema.ID)
-	}
-
-	field.Create = false
-	field.Update = false
-	schema.ResourceFields[r.Field] = field
-
-	return nil
-}
diff --git a/types/mapping/mapper/swap.go b/types/mapping/mapper/swap.go
deleted file mode 100644
index f135ac4c3..000000000
--- a/types/mapping/mapper/swap.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package mapper
-
-type Swap struct {
-	Left, Right string
-}
-
-func (s Swap) Forward(data map[string]interface{}) {
-	rightValue, rightOk := data[s.Right]
-	leftValue, leftOk := data[s.Left]
-	if rightOk {
-		data[s.Left] = rightValue
-	}
-	if leftOk {
-		data[s.Right] = leftValue
-	}
-}
-
-func (s Swap) Back(data map[string]interface{}) {
-	s.Forward(data)
-}
diff --git a/types/mapping/mapper/type.go b/types/mapping/mapper/type.go
deleted file mode 100644
index ad5eac359..000000000
--- a/types/mapping/mapper/type.go
+++ /dev/null
@@ -1 +0,0 @@
-package mapper
diff --git a/types/reflection.go b/types/reflection.go
index e0e5e968a..2c7bd6ee5 100644
--- a/types/reflection.go
+++ b/types/reflection.go
@@ -6,12 +6,17 @@ import (
 	"strconv"
 	"strings"
 
+	"net/http"
+
 	"github.com/rancher/norman/types/convert"
+	"github.com/rancher/norman/types/definition"
+	"github.com/rancher/norman/types/slice"
 	"github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 var (
+	namespacedType = reflect.TypeOf(Namespaced{})
 	resourceType   = reflect.TypeOf(Resource{})
 	typeType       = reflect.TypeOf(metav1.TypeMeta{})
 	metaType       = reflect.TypeOf(metav1.ObjectMeta{})
@@ -21,10 +26,17 @@ var (
 	}
 )
 
-func (s *Schemas) AddMapperForType(version *APIVersion, obj interface{}, mapper Mapper) *Schemas {
+func (s *Schemas) AddMapperForType(version *APIVersion, obj interface{}, mapper ...Mapper) *Schemas {
+	if len(mapper) == 0 {
+		return s
+	}
+
 	t := reflect.TypeOf(obj)
 	typeName := convert.LowerTitle(t.Name())
-	return s.AddMapper(version, typeName, mapper)
+	if len(mapper) == 1 {
+		return s.AddMapper(version, typeName, mapper[0])
+	}
+	return s.AddMapper(version, typeName, Mappers(mapper))
 }
 
 func (s *Schemas) MustImport(version *APIVersion, obj interface{}, externalOverrides ...interface{}) *Schemas {
@@ -36,8 +48,13 @@ func (s *Schemas) MustImport(version *APIVersion, obj interface{}, externalOverr
 	return s
 }
 
+func (s *Schemas) MustImportAndCustomize(version *APIVersion, obj interface{}, f func(*Schema), externalOverrides ...interface{}) *Schemas {
+	return s.MustImport(version, obj, externalOverrides...).
+		MustCustomizeType(version, obj, f)
+}
+
 func (s *Schemas) Import(version *APIVersion, obj interface{}, externalOverrides ...interface{}) (*Schema, error) {
-	types := []reflect.Type{}
+	var types []reflect.Type
 	for _, override := range externalOverrides {
 		types = append(types, reflect.TypeOf(override))
 	}
@@ -61,6 +78,54 @@ func (s *Schemas) newSchemaFromType(version *APIVersion, t reflect.Type, typeNam
 	return schema, nil
 }
 
+func (s *Schemas) setupFilters(schema *Schema) {
+	if !slice.ContainsString(schema.CollectionMethods, http.MethodGet) {
+		return
+	}
+	for fieldName, field := range schema.ResourceFields {
+		var mods []ModifierType
+		switch field.Type {
+		case "enum":
+			mods = []ModifierType{ModifierEQ, ModifierNE, ModifierIn, ModifierNotIn}
+		case "string":
+			mods = []ModifierType{ModifierEQ, ModifierNE, ModifierIn, ModifierNotIn}
+		case "int":
+			mods = []ModifierType{ModifierEQ, ModifierNE, ModifierIn, ModifierNotIn}
+		case "boolean":
+			mods = []ModifierType{ModifierEQ, ModifierNE}
+		default:
+			if definition.IsReferenceType(field.Type) {
+				mods = []ModifierType{ModifierEQ, ModifierNE, ModifierIn, ModifierNotIn}
+			}
+		}
+
+		if len(mods) > 0 {
+			if schema.CollectionFilters == nil {
+				schema.CollectionFilters = map[string]Filter{}
+			}
+			schema.CollectionFilters[fieldName] = Filter{
+				Modifiers: mods,
+			}
+		}
+	}
+}
+
+func (s *Schemas) MustCustomizeType(version *APIVersion, obj interface{}, f func(*Schema)) *Schemas {
+	name := convert.LowerTitle(reflect.TypeOf(obj).Name())
+	schema := s.Schema(version, name)
+	if schema == nil {
+		panic("Failed to find schema " + name)
+	}
+
+	f(schema)
+
+	if schema.SubContext != "" {
+		s.schemasBySubContext[schema.SubContext] = schema
+	}
+
+	return s
+}
+
 func (s *Schemas) importType(version *APIVersion, t reflect.Type, overrides ...reflect.Type) (*Schema, error) {
 	typeName := convert.LowerTitle(t.Name())
 
@@ -76,8 +141,13 @@ func (s *Schemas) importType(version *APIVersion, t reflect.Type, overrides ...r
 		return nil, err
 	}
 
-	mapper := s.mapper(&schema.Version, schema.ID)
-	if mapper != nil {
+	mappers := s.mapper(&schema.Version, schema.ID)
+	if schema.CanList() {
+		mappers = append(s.DefaultMappers, mappers...)
+	}
+	mappers = append(mappers, s.DefaultPostMappers...)
+
+	if len(mappers) > 0 {
 		copy, err := s.newSchemaFromType(version, t, typeName)
 		if err != nil {
 			return nil, err
@@ -91,14 +161,16 @@ func (s *Schemas) importType(version *APIVersion, t reflect.Type, overrides ...r
 		}
 	}
 
-	if mapper == nil {
-		mapper = &TypeMapper{}
+	mapper := &typeMapper{
+		Mappers: mappers,
 	}
 
 	if err := mapper.ModifySchema(schema, s); err != nil {
 		return nil, err
 	}
 
+	s.setupFilters(schema)
+
 	schema.Mapper = mapper
 	s.AddSchema(schema)
 
@@ -146,6 +218,9 @@ func (s *Schemas) readFields(schema *Schema, t reflect.Type) error {
 				t = t.Elem()
 			}
 			if t.Kind() == reflect.Struct {
+				if t == namespacedType {
+					schema.Scope = NamespaceScope
+				}
 				if err := s.readFields(schema, t); err != nil {
 					return err
 				}
@@ -156,6 +231,9 @@ func (s *Schemas) readFields(schema *Schema, t reflect.Type) error {
 		fieldName := jsonName
 		if fieldName == "" {
 			fieldName = convert.LowerTitle(field.Name)
+			if strings.HasSuffix(fieldName, "ID") {
+				fieldName = strings.TrimSuffix(fieldName, "ID") + "Id"
+			}
 		}
 
 		if blacklistNames[fieldName] {
@@ -168,6 +246,7 @@ func (s *Schemas) readFields(schema *Schema, t reflect.Type) error {
 		schemaField := Field{
 			Create:   true,
 			Update:   true,
+			Nullable: true,
 			CodeName: field.Name,
 		}
 
diff --git a/types/schema_funcs.go b/types/schema_funcs.go
new file mode 100644
index 000000000..df6f6ff6d
--- /dev/null
+++ b/types/schema_funcs.go
@@ -0,0 +1,26 @@
+package types
+
+import (
+	"net/http"
+
+	"github.com/rancher/norman/types/slice"
+)
+
+func (s *Schema) MustCustomizeField(name string, f func(f Field) Field) *Schema {
+	field, ok := s.ResourceFields[name]
+	if !ok {
+		panic("Failed to find field " + name + " on schema " + s.ID)
+	}
+	s.ResourceFields[name] = f(field)
+	return s
+}
+
+func (v *APIVersion) Equals(other *APIVersion) bool {
+	return v.Version == other.Version &&
+		v.Group == other.Group &&
+		v.Path == other.Path
+}
+
+func (s *Schema) CanList() bool {
+	return slice.ContainsString(s.CollectionMethods, http.MethodGet)
+}
diff --git a/types/schemas.go b/types/schemas.go
index bbdf42562..047021ee9 100644
--- a/types/schemas.go
+++ b/types/schemas.go
@@ -16,17 +16,21 @@ type SchemaCollection struct {
 type SchemaInitFunc func(*Schemas) *Schemas
 
 type Schemas struct {
-	schemasByPath map[string]map[string]*Schema
-	mappers       map[string]map[string]Mapper
-	versions      []APIVersion
-	schemas       []*Schema
-	errors        []error
+	schemasByPath       map[string]map[string]*Schema
+	schemasBySubContext map[string]*Schema
+	mappers             map[string]map[string][]Mapper
+	DefaultMappers      []Mapper
+	DefaultPostMappers  []Mapper
+	versions            []APIVersion
+	schemas             []*Schema
+	errors              []error
 }
 
 func NewSchemas() *Schemas {
 	return &Schemas{
-		schemasByPath: map[string]map[string]*Schema{},
-		mappers:       map[string]map[string]Mapper{},
+		schemasByPath:       map[string]map[string]*Schema{},
+		schemasBySubContext: map[string]*Schema{},
+		mappers:             map[string]map[string][]Mapper{},
 	}
 }
 
@@ -38,6 +42,14 @@ func (s *Schemas) Err() error {
 	return NewErrors(s.errors)
 }
 
+func (s *Schemas) SubContext(subContext string) *Schema {
+	return s.schemasBySubContext[subContext]
+}
+
+func (s *Schemas) SubContextSchemas() map[string]*Schema {
+	return s.schemasBySubContext
+}
+
 func (s *Schemas) AddSchemas(schema *Schemas) *Schemas {
 	for _, schema := range schema.Schemas() {
 		s.AddSchema(schema)
@@ -46,7 +58,7 @@ func (s *Schemas) AddSchemas(schema *Schemas) *Schemas {
 }
 
 func (s *Schemas) AddSchema(schema *Schema) *Schemas {
-	schema.Type = "schema"
+	schema.Type = "/v1-meta/schemas/schema"
 	if schema.ID == "" {
 		s.errors = append(s.errors, fmt.Errorf("ID is not set on schema: %v", schema))
 		return s
@@ -64,6 +76,9 @@ func (s *Schemas) AddSchema(schema *Schema) *Schemas {
 	if schema.CodeNamePlural == "" {
 		schema.CodeNamePlural = name.GuessPluralName(schema.CodeName)
 	}
+	if schema.BaseType == "" {
+		schema.BaseType = schema.ID
+	}
 
 	schemas, ok := s.schemasByPath[schema.Version.Path]
 	if !ok {
@@ -77,20 +92,21 @@ func (s *Schemas) AddSchema(schema *Schema) *Schemas {
 		s.schemas = append(s.schemas, schema)
 	}
 
+	if schema.SubContext != "" {
+		s.schemasBySubContext[schema.SubContext] = schema
+	}
+
 	return s
 }
 
 func (s *Schemas) AddMapper(version *APIVersion, schemaID string, mapper Mapper) *Schemas {
 	mappers, ok := s.mappers[version.Path]
 	if !ok {
-		mappers = map[string]Mapper{}
+		mappers = map[string][]Mapper{}
 		s.mappers[version.Path] = mappers
 	}
 
-	if _, ok := mappers[schemaID]; !ok {
-		mappers[schemaID] = mapper
-	}
-
+	mappers[schemaID] = append(mappers[schemaID], mapper)
 	return s
 }
 
@@ -106,7 +122,7 @@ func (s *Schemas) Schemas() []*Schema {
 	return s.schemas
 }
 
-func (s *Schemas) mapper(version *APIVersion, name string) Mapper {
+func (s *Schemas) mapper(version *APIVersion, name string) []Mapper {
 	var (
 		path string
 	)
@@ -139,10 +155,10 @@ func (s *Schemas) Schema(version *APIVersion, name string) *Schema {
 		path string
 	)
 
-	if strings.Contains(name, "/") {
-		idx := strings.LastIndex(name, "/")
-		path = name[0:idx]
-		name = name[idx+1:]
+	if strings.Contains(name, "/schemas/") {
+		parts := strings.SplitN(name, "/schemas/", 2)
+		path = parts[0]
+		name = parts[1]
 	} else if version != nil {
 		path = version.Path
 	} else {
diff --git a/types/server_types.go b/types/server_types.go
index b6f1ba6a1..fd452f82a 100644
--- a/types/server_types.go
+++ b/types/server_types.go
@@ -27,7 +27,9 @@ func (r *RawResource) MarshalJSON() ([]byte, error) {
 	if r.ID != "" {
 		data["id"] = r.ID
 	}
+
 	data["type"] = r.Type
+	data["baseType"] = r.Schema.BaseType
 	data["links"] = r.Links
 	if r.ActionLinks {
 		data["actionLinks"] = r.Actions
@@ -41,12 +43,19 @@ type ActionHandler func(actionName string, action *Action, request *APIContext)
 
 type RequestHandler func(request *APIContext) error
 
+type QueryFilter func(opts QueryOptions, data []map[string]interface{}) []map[string]interface{}
+
 type Validator func(request *APIContext, data map[string]interface{}) error
 
 type Formatter func(request *APIContext, resource *RawResource)
 
 type ErrorHandler func(request *APIContext, err error)
 
+type SubContextAttributeProvider interface {
+	Query(apiContext *APIContext, schema *Schema) []*QueryCondition
+	Create(apiContext *APIContext, schema *Schema) map[string]interface{}
+}
+
 type ResponseWriter interface {
 	Write(apiContext *APIContext, code int, obj interface{})
 }
@@ -57,22 +66,24 @@ type AccessControl interface {
 }
 
 type APIContext struct {
-	Action             string
-	ID                 string
-	Type               string
-	Link               string
-	Method             string
-	Schema             *Schema
-	Schemas            *Schemas
-	Version            *APIVersion
-	ResponseFormat     string
-	ReferenceValidator ReferenceValidator
-	ResponseWriter     ResponseWriter
-	QueryOptions       *QueryOptions
-	Body               map[string]interface{}
-	URLBuilder         URLBuilder
-	AccessControl      AccessControl
-	SubContext         map[string]interface{}
+	Action                      string
+	ID                          string
+	Type                        string
+	Link                        string
+	Method                      string
+	Schema                      *Schema
+	Schemas                     *Schemas
+	Version                     *APIVersion
+	ResponseFormat              string
+	ReferenceValidator          ReferenceValidator
+	ResponseWriter              ResponseWriter
+	QueryFilter                 QueryFilter
+	SubContextAttributeProvider SubContextAttributeProvider
+	//QueryOptions                *QueryOptions
+	URLBuilder    URLBuilder
+	AccessControl AccessControl
+	SubContext    map[string]string
+	Attributes    map[string]interface{}
 
 	Request  *http.Request
 	Response http.ResponseWriter
@@ -82,6 +93,30 @@ func (r *APIContext) WriteResponse(code int, obj interface{}) {
 	r.ResponseWriter.Write(r, code, obj)
 }
 
+func (r *APIContext) FilterList(opts QueryOptions, obj []map[string]interface{}) []map[string]interface{} {
+	return r.QueryFilter(opts, obj)
+}
+
+func (r *APIContext) FilterObject(opts QueryOptions, obj map[string]interface{}) map[string]interface{} {
+	opts.Pagination = nil
+	result := r.QueryFilter(opts, []map[string]interface{}{obj})
+	if len(result) == 0 {
+		return nil
+	}
+	return result[0]
+}
+
+func (r *APIContext) Filter(opts QueryOptions, obj interface{}) interface{} {
+	switch v := obj.(type) {
+	case []map[string]interface{}:
+		return r.FilterList(opts, v)
+	case map[string]interface{}:
+		return r.FilterObject(opts, v)
+	}
+
+	return nil
+}
+
 var (
 	ASC  = SortOrder("asc")
 	DESC = SortOrder("desc")
@@ -100,20 +135,21 @@ type ReferenceValidator interface {
 
 type URLBuilder interface {
 	Current() string
-	Collection(schema *Schema) string
+	Collection(schema *Schema, versionOverride *APIVersion) string
+	SubContextCollection(subContext *Schema, contextName string, schema *Schema) string
+	SchemaLink(schema *Schema) string
 	ResourceLink(resource *RawResource) string
 	RelativeToRoot(path string) string
-	//Link(resource Resource, name string) string
-	//ReferenceLink(resource Resource) string
-	//ReferenceByIdLink(resourceType string, id string) string
-	Version(version string) string
+	Version(version APIVersion) string
+	Marker(marker string) string
 	ReverseSort(order SortOrder) string
+	Sort(field string) string
 	SetSubContext(subContext string)
 }
 
 type Store interface {
 	ByID(apiContext *APIContext, schema *Schema, id string) (map[string]interface{}, error)
-	List(apiContext *APIContext, schema *Schema, opt *QueryOptions) ([]map[string]interface{}, error)
+	List(apiContext *APIContext, schema *Schema, opt QueryOptions) ([]map[string]interface{}, error)
 	Create(apiContext *APIContext, schema *Schema, data map[string]interface{}) (map[string]interface{}, error)
 	Update(apiContext *APIContext, schema *Schema, data map[string]interface{}, id string) (map[string]interface{}, error)
 	Delete(apiContext *APIContext, schema *Schema, id string) error
diff --git a/types/slice/contains.go b/types/slice/contains.go
new file mode 100644
index 000000000..170f11d11
--- /dev/null
+++ b/types/slice/contains.go
@@ -0,0 +1,10 @@
+package slice
+
+func ContainsString(slice []string, item string) bool {
+	for _, j := range slice {
+		if j == item {
+			return true
+		}
+	}
+	return false
+}
diff --git a/types/types.go b/types/types.go
index 36eddca1e..b465f86ab 100644
--- a/types/types.go
+++ b/types/types.go
@@ -27,12 +27,23 @@ type Sort struct {
 	Name    string            `json:"name,omitempty"`
 	Order   SortOrder         `json:"order,omitempty"`
 	Reverse string            `json:"reverse,omitempty"`
-	Links   map[string]string `json:"sortLinks,omitempty"`
+	Links   map[string]string `json:"links,omitempty"`
 }
 
+var (
+	ModifierEQ      ModifierType = "eq"
+	ModifierNE      ModifierType = "ne"
+	ModifierNull    ModifierType = "null"
+	ModifierNotNull ModifierType = "notnull"
+	ModifierIn      ModifierType = "in"
+	ModifierNotIn   ModifierType = "notin"
+)
+
+type ModifierType string
+
 type Condition struct {
-	Modifier string      `json:"modifier,omitempty"`
-	Value    interface{} `json:"value,omitempty"`
+	Modifier ModifierType `json:"modifier,omitempty"`
+	Value    interface{}  `json:"value,omitempty"`
 }
 
 type Pagination struct {
@@ -40,6 +51,7 @@ type Pagination struct {
 	First    string `json:"first,omitempty"`
 	Previous string `json:"previous,omitempty"`
 	Next     string `json:"next,omitempty"`
+	Last     string `json:"last,omitempty"`
 	Limit    *int64 `json:"limit,omitempty"`
 	Total    *int64 `json:"total,omitempty"`
 	Partial  bool   `json:"partial,omitempty"`
@@ -59,12 +71,20 @@ type APIVersion struct {
 	SubContexts map[string]bool `json:"subContext,omitempty"`
 }
 
+type Namespaced struct{}
+
+var NamespaceScope TypeScope = "namespace"
+
+type TypeScope string
+
 type Schema struct {
 	ID                string            `json:"id,omitempty"`
 	CodeName          string            `json:"-"`
 	CodeNamePlural    string            `json:"-"`
 	PkgName           string            `json:"-"`
 	Type              string            `json:"type,omitempty"`
+	BaseType          string            `json:"baseType,omitempty"`
+	SubContext        string            `json:"-,omitempty"`
 	Links             map[string]string `json:"links"`
 	Version           APIVersion        `json:"version"`
 	PluralName        string            `json:"pluralName,omitempty"`
@@ -75,6 +95,7 @@ type Schema struct {
 	CollectionFields  map[string]Field  `json:"collectionFields,omitempty"`
 	CollectionActions map[string]Action `json:"collectionActions,omitempty"`
 	CollectionFilters map[string]Filter `json:"collectionFilters,omitempty"`
+	Scope             TypeScope         `json:"-"`
 
 	InternalSchema *Schema        `json:"-"`
 	Mapper         Mapper         `json:"-"`
@@ -115,7 +136,7 @@ type Action struct {
 }
 
 type Filter struct {
-	Modifiers []string `json:"modifiers,omitempty"`
+	Modifiers []ModifierType `json:"modifiers,omitempty"`
 }
 
 type ListOpts struct {
diff --git a/urlbuilder/url.go b/urlbuilder/url.go
index eabfda1d5..ea33ead59 100644
--- a/urlbuilder/url.go
+++ b/urlbuilder/url.go
@@ -12,23 +12,23 @@ import (
 )
 
 const (
-	DEFAULT_OVERRIDE_URL_HEADER = "X-API-request-url"
-	FORWARDED_HOST_HEADER       = "X-Forwarded-Host"
-	FORWARDED_PROTO_HEADER      = "X-Forwarded-Proto"
-	FORWARDED_PORT_HEADER       = "X-Forwarded-Port"
+	DefaultOverrideURLHeader = "X-API-request-url"
+	ForwardedHostHeader      = "X-Forwarded-Host"
+	ForwardedProtoHeader     = "X-Forwarded-Proto"
+	ForwardedPortHeader      = "X-Forwarded-Port"
 )
 
 func New(r *http.Request, version types.APIVersion, schemas *types.Schemas) (types.URLBuilder, error) {
-	requestUrl := parseRequestUrl(r)
-	responseUrlBase, err := parseResponseUrlBase(requestUrl, r)
+	requestURL := parseRequestURL(r)
+	responseURLBase, err := parseResponseURLBase(requestURL, r)
 	if err != nil {
 		return nil, err
 	}
 
 	builder := &urlBuilder{
 		schemas:         schemas,
-		requestUrl:      requestUrl,
-		responseUrlBase: responseUrlBase,
+		requestURL:      requestURL,
+		responseURLBase: responseURLBase,
 		apiVersion:      version,
 		query:           r.URL.Query(),
 	}
@@ -38,8 +38,8 @@ func New(r *http.Request, version types.APIVersion, schemas *types.Schemas) (typ
 
 type urlBuilder struct {
 	schemas         *types.Schemas
-	requestUrl      string
-	responseUrlBase string
+	requestURL      string
+	responseURLBase string
 	apiVersion      types.APIVersion
 	subContext      string
 	query           url.Values
@@ -49,12 +49,25 @@ func (u *urlBuilder) SetSubContext(subContext string) {
 	u.subContext = subContext
 }
 
+func (u *urlBuilder) SchemaLink(schema *types.Schema) string {
+	return u.constructBasicURL(schema.Version, "schemas", schema.ID)
+}
+
 func (u *urlBuilder) ResourceLink(resource *types.RawResource) string {
 	if resource.ID == "" {
 		return ""
 	}
 
-	return u.constructBasicUrl(resource.Schema.Version, resource.Schema.PluralName, resource.ID)
+	return u.constructBasicURL(resource.Schema.Version, resource.Schema.PluralName, resource.ID)
+}
+
+func (u *urlBuilder) Marker(marker string) string {
+	newValues := url.Values{}
+	for k, v := range u.query {
+		newValues[k] = v
+	}
+	newValues.Set("marker", marker)
+	return u.requestURL + "?" + newValues.Encode()
 }
 
 func (u *urlBuilder) ReverseSort(order types.SortOrder) string {
@@ -70,30 +83,48 @@ func (u *urlBuilder) ReverseSort(order types.SortOrder) string {
 		newValues.Add("order", string(types.ASC))
 	}
 
-	return u.requestUrl + "?" + newValues.Encode()
+	return u.requestURL + "?" + newValues.Encode()
 }
 
 func (u *urlBuilder) Current() string {
-	return u.requestUrl
+	return u.requestURL
 }
 
 func (u *urlBuilder) RelativeToRoot(path string) string {
-	return u.responseUrlBase + path
+	return u.responseURLBase + path
 }
 
-func (u *urlBuilder) Collection(schema *types.Schema) string {
+func (u *urlBuilder) Sort(field string) string {
+	newValues := url.Values{}
+	for k, v := range u.query {
+		newValues[k] = v
+	}
+	newValues.Del("order")
+	newValues.Del("marker")
+	newValues.Set("sort", field)
+	return u.requestURL + "?" + newValues.Encode()
+}
+
+func (u *urlBuilder) Collection(schema *types.Schema, versionOverride *types.APIVersion) string {
 	plural := u.getPluralName(schema)
-	return u.constructBasicUrl(schema.Version, plural)
+	if versionOverride == nil {
+		return u.constructBasicURL(schema.Version, plural)
+	}
+	return u.constructBasicURL(*versionOverride, plural)
+}
+
+func (u *urlBuilder) SubContextCollection(subContext *types.Schema, contextName string, schema *types.Schema) string {
+	return u.constructBasicURL(schema.Version, subContext.SubContext, contextName, u.getPluralName(schema))
 }
 
-func (u *urlBuilder) Version(version string) string {
-	return fmt.Sprintf("%s/%s", u.responseUrlBase, version)
+func (u *urlBuilder) Version(version types.APIVersion) string {
+	return u.constructBasicURL(version)
 }
 
-func (u *urlBuilder) constructBasicUrl(version types.APIVersion, parts ...string) string {
+func (u *urlBuilder) constructBasicURL(version types.APIVersion, parts ...string) string {
 	buffer := bytes.Buffer{}
 
-	buffer.WriteString(u.responseUrlBase)
+	buffer.WriteString(u.responseURLBase)
 	if version.Path == "" {
 		buffer.WriteString(u.apiVersion.Path)
 	} else {
@@ -130,30 +161,30 @@ func (u *urlBuilder) getPluralName(schema *types.Schema) string {
 // Additional notes:
 //  - With x-api-request-url, the query string is passed, it will be dropped to match the other formats.
 //  - If the x-forwarded-host/host header has a port and x-forwarded-port has been passed, x-forwarded-port will be used.
-func parseRequestUrl(r *http.Request) string {
+func parseRequestURL(r *http.Request) string {
 	// Get url from custom x-api-request-url header
-	requestUrl := getOverrideHeader(r, DEFAULT_OVERRIDE_URL_HEADER, "")
-	if requestUrl != "" {
-		return strings.SplitN(requestUrl, "?", 2)[0]
+	requestURL := getOverrideHeader(r, DefaultOverrideURLHeader, "")
+	if requestURL != "" {
+		return strings.SplitN(requestURL, "?", 2)[0]
 	}
 
 	// Get url from standard headers
-	requestUrl = getUrlFromStandardHeaders(r)
-	if requestUrl != "" {
-		return requestUrl
+	requestURL = getURLFromStandardHeaders(r)
+	if requestURL != "" {
+		return requestURL
 	}
 
 	// Use incoming url
 	return fmt.Sprintf("http://%s%s", r.Host, r.URL.Path)
 }
 
-func getUrlFromStandardHeaders(r *http.Request) string {
-	xForwardedProto := getOverrideHeader(r, FORWARDED_PROTO_HEADER, "")
+func getURLFromStandardHeaders(r *http.Request) string {
+	xForwardedProto := getOverrideHeader(r, ForwardedProtoHeader, "")
 	if xForwardedProto == "" {
 		return ""
 	}
 
-	host := getOverrideHeader(r, FORWARDED_HOST_HEADER, "")
+	host := getOverrideHeader(r, ForwardedHostHeader, "")
 	if host == "" {
 		host = r.Host
 	}
@@ -162,7 +193,7 @@ func getUrlFromStandardHeaders(r *http.Request) string {
 		return ""
 	}
 
-	port := getOverrideHeader(r, FORWARDED_PORT_HEADER, "")
+	port := getOverrideHeader(r, ForwardedPortHeader, "")
 	if port == "443" || port == "80" {
 		port = "" // Don't include default ports in url
 	}
@@ -190,13 +221,13 @@ func getOverrideHeader(r *http.Request, header string, defaultValue string) stri
 	return defaultValue
 }
 
-func parseResponseUrlBase(requestUrl string, r *http.Request) (string, error) {
+func parseResponseURLBase(requestURL string, r *http.Request) (string, error) {
 	path := r.URL.Path
 
-	index := strings.LastIndex(requestUrl, path)
+	index := strings.LastIndex(requestURL, path)
 	if index == -1 {
-		// Fallback, if we can't find path in requestUrl, then we just assume the base is the root of the web request
-		u, err := url.Parse(requestUrl)
+		// Fallback, if we can't find path in requestURL, then we just assume the base is the root of the web request
+		u, err := url.Parse(requestURL)
 		if err != nil {
 			return "", err
 		}
@@ -206,7 +237,7 @@ func parseResponseUrlBase(requestUrl string, r *http.Request) (string, error) {
 		buffer.WriteString("://")
 		buffer.WriteString(u.Host)
 		return buffer.String(), nil
-	} else {
-		return requestUrl[0:index], nil
 	}
+
+	return requestURL[0:index], nil
 }