func secrets(dm *DependencyManager) func(...string) ([]corev1.Secret, error) {
	return func(s ...string) ([]corev1.Secret, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.Secrets(namespace, selector)
		} else {
			return nil, err
		}
	}
}
{{secrets "selector" "namespace"}}
package main
import (
	corev1 "k8s.io/api/core/v1"
)
func kubeObjectsFuncMap(dm *DependencyManager) map[string]interface{} {
	return map[string]interface{}{
		"pods":                   pods(dm),
		"services":               services(dm),
		"replicationcontrollers": replicationcontrollers(dm),
		"events":                 events(dm),
		"endpoints":              endpoints(dm),
		"nodes":                  nodes(dm),
		"namespaces":             namespaces(dm),
		"componentstatuses":      componentstatuses(dm),
		"configmaps":             configmaps(dm),
		"limitranges":            limitranges(dm),
		"persistentvolumes":      persistentvolumes(dm),
		"persistentvolumeclaims": persistentvolumeclaims(dm),
		"podtemplates":           podtemplates(dm),
		"resourcequotas":         resourcequotas(dm),
		"secrets":                secrets(dm),
		"serviceaccounts":        serviceaccounts(dm),
	}
}
func pods(dm *DependencyManager) func(...string) ([]corev1.Pod, error) {
	return func(s ...string) ([]corev1.Pod, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.Pods(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func services(dm *DependencyManager) func(...string) ([]corev1.Service, error) {
	return func(s ...string) ([]corev1.Service, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.Services(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func replicationcontrollers(dm *DependencyManager) func(...string) ([]corev1.ReplicationController, error) {
	return func(s ...string) ([]corev1.ReplicationController, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.ReplicationControllers(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func events(dm *DependencyManager) func(...string) ([]corev1.Event, error) {
	return func(s ...string) ([]corev1.Event, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.Events(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func endpoints(dm *DependencyManager) func(...string) ([]corev1.Endpoints, error) {
	return func(s ...string) ([]corev1.Endpoints, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.Endpoints(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func nodes(dm *DependencyManager) func(...string) ([]corev1.Node, error) {
	return func(s ...string) ([]corev1.Node, error) {
		if selector, err := parseSelector(s...); err == nil {
			return dm.Nodes(selector)
		} else {
			return nil, err
		}
	}
}
func namespaces(dm *DependencyManager) func(...string) ([]corev1.Namespace, error) {
	return func(s ...string) ([]corev1.Namespace, error) {
		if selector, err := parseSelector(s...); err == nil {
			return dm.Namespaces(selector)
		} else {
			return nil, err
		}
	}
}
func componentstatuses(dm *DependencyManager) func(...string) ([]corev1.ComponentStatus, error) {
	return func(s ...string) ([]corev1.ComponentStatus, error) {
		if selector, err := parseSelector(s...); err == nil {
			return dm.ComponentStatuses(selector)
		} else {
			return nil, err
		}
	}
}
func configmaps(dm *DependencyManager) func(...string) ([]corev1.ConfigMap, error) {
	return func(s ...string) ([]corev1.ConfigMap, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.ConfigMaps(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func limitranges(dm *DependencyManager) func(...string) ([]corev1.LimitRange, error) {
	return func(s ...string) ([]corev1.LimitRange, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.LimitRanges(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func persistentvolumes(dm *DependencyManager) func(...string) ([]corev1.PersistentVolume, error) {
	return func(s ...string) ([]corev1.PersistentVolume, error) {
		if selector, err := parseSelector(s...); err == nil {
			return dm.PersistentVolumes(selector)
		} else {
			return nil, err
		}
	}
}
func persistentvolumeclaims(dm *DependencyManager) func(...string) ([]corev1.PersistentVolumeClaim, error) {
	return func(s ...string) ([]corev1.PersistentVolumeClaim, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.PersistentVolumeClaims(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func podtemplates(dm *DependencyManager) func(...string) ([]corev1.PodTemplate, error) {
	return func(s ...string) ([]corev1.PodTemplate, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.PodTemplates(namespace, selector)
		} else {
			return nil, err
		}
	}
}
func resourcequotas(dm *DependencyManager) func(...string) ([]corev1.ResourceQuota, error) {
	return func(s ...string) ([]corev1.ResourceQuota, error) {
		if namespace, selector, err := parseNamespaceSelector(s...); err == nil {
			return dm.ResourceQuotas(namespace, selector)
		} else {
			return nil, err
		}
	}
}