newClaim := obj.(*resource.ResourceClaim)
	oldClaim := old.(*resource.ResourceClaim)
	newClaim.Status = oldClaim.Status
}

func (resourceclaimStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {
	newClaim := obj.(*resource.ResourceClaim)
	oldClaim := old.(*resource.ResourceClaim)
	errorList := validation.ValidateClaim(newClaim)

)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&ResourceClass{},
		&ResourceClassList{},
		&ResourceClaim{},
		&ResourceClaimList{},
		&ResourceClaimTemplate{},
		&ResourceClaimTemplateList{},
		&PodSchedulingContext{},
		&PodSchedulingContextList{},
		&ResourceSlice{},
		&ResourceSliceList{},

	if err := scheme.AddIgnoredConversionType(&metav1.TypeMeta{}, &metav1.TypeMeta{}); err != nil {
		return err
	}
	scheme.AddKnownTypes(SchemeGroupVersion,
		&ResourceClass{},
		&ResourceClassList{},
		&ResourceClaim{},
		&ResourceClaimList{},
		&ResourceClaimTemplate{},
		&ResourceClaimTemplateList{},
		&PodSchedulingContext{},
		&PodSchedulingContextList{},
		&ResourceSlice{},
		&ResourceSliceList{},

	for _, obj := range objs {
		claim, ok := obj.(*resourcev1alpha2.ResourceClaim)
		if !ok {
			return nil, fmt.Errorf("got unexpected object of type %T from claim assume cache", obj)
		}
		if obj, ok := inFlightAllocations.Load(claim.UID); ok {
			// If the allocation is in-flight, then we have to use the allocation
			// from that claim.
			claim = obj.(*resourcev1alpha2.ResourceClaim)
		}
		if claim.Status.Allocation == nil {
			continue

func newClaimInfoFromClaim(claim *resourcev1alpha2.ResourceClaim) *ClaimInfo {
	// Grab the allocation.resourceHandles. If there are no
	// allocation.resourceHandles, create a single resourceHandle with no
	// content. This will trigger processing of this claim by a single
	// kubelet plugin whose name matches resourceClaim.Status.DriverName.
	resourceHandles := claim.Status.Allocation.ResourceHandles

	resourceclaimstore "k8s.io/kubernetes/pkg/registry/resource/resourceclaim/storage"
	resourceclaimparametersstore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimparameters/storage"
	resourceclaimtemplatestore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimtemplate/storage"
	resourceclassstore "k8s.io/kubernetes/pkg/registry/resource/resourceclass/storage"

func GetAttrs(obj runtime.Object) (labels.Set, fields.Set, error) {
	parameters, ok := obj.(*resource.ResourceClaimParameters)
	if !ok {
		return nil, nil, errors.New("not a resourceclaim")
	}
	return labels.Set(parameters.Labels), toSelectableFields(parameters), nil
}

// toSelectableFields returns a field set that represents the object

	EphemeralVolumeController                    = "ephemeral-volume-controller"
	StorageVersionGarbageCollectorController     = "storageversion-garbage-collector-controller"
	ResourceClaimController                      = "resourceclaim-controller"
	LegacyServiceAccountTokenCleanerController   = "legacy-serviceaccount-token-cleaner-controller"
	ValidatingAdmissionPolicyStatusController    = "validatingadmissionpolicy-status-controller"

type podSchedulingStrategy struct {
	runtime.ObjectTyper
	names.NameGenerator
}

// Strategy is the default logic that applies when creating and updating
// ResourceClaim objects via the REST API.
var Strategy = podSchedulingStrategy{legacyscheme.Scheme, names.SimpleNameGenerator}

func (podSchedulingStrategy) NamespaceScoped() bool {
	return true
}

		// This plugin should come before DefaultPreemption because if
		// there is a problem with a Pod and PostFilter gets called to
		// resolve the problem, it is better to first deallocate an
		// idle ResourceClaim than it is to evict some Pod that might
		// be doing useful work.
		for i := range config.MultiPoint.Enabled {
			if config.MultiPoint.Enabled[i].Name == names.DefaultPreemption {