expect: authorizer.DecisionNoOpinion,
		},
		{
			name:   "allowed list ResourceSlices",
			attrs:  authorizer.AttributesRecord{User: node0, ResourceRequest: true, Verb: "list", Resource: "resourceslices", APIGroup: "resource.k8s.io"},
			expect: authorizer.DecisionAllow,
		},
		{
			name:   "allowed watch ResourceSlices",

			slice, ok := obj.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}
			logger.V(5).Info("ResourceSlice add", "slice", klog.KObj(slice))
			c.queue.Add(slice.DriverName)
		},
		UpdateFunc: func(old, new any) {
			oldSlice, ok := old.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}
			newSlice, ok := new.(*resourceapi.ResourceSlice)
			if !ok {
				return
			}

        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "ResourceSlice",
      "name": "resourceslices",
      "namespaced": false,
      "singularName": "resourceslice",
      "storageVersionHash": "IECvOcO76kw=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",

		NewListFunc:               func() runtime.Object { return &resource.ResourceSliceList{} },
		PredicateFunc:             resourceslice.Match,
		DefaultQualifiedResource:  resource.Resource("resourceslices"),
		SingularQualifiedResource: resource.Resource("resourceslice"),

		CreateStrategy:      resourceslice.Strategy,
		UpdateStrategy:      resourceslice.Strategy,

		DeleteCollectionWorkers: 1,
		ResourcePrefix:          "resourceslices",
	}
	resourceClassStorage, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return resourceClassStorage, server
}

func validNewResourceSlice(name string) *resource.ResourceSlice {
	return &resource.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
		},

		if err != nil {
			return nil, err
		}
		storage[resource] = resourceClassParametersStorage
	}

	if resource := "resourceslices"; apiResourceConfigSource.ResourceEnabled(resourcev1alpha2.SchemeGroupVersion.WithResource(resource)) {
		resourceSliceStorage, err := resourceslicestore.NewREST(restOptionsGetter)
		if err != nil {
			return nil, err
		}

}

// authorizeResourceSlice authorizes node requests to ResourceSlice resource.k8s.io/resourceslices
func (r *NodeAuthorizer) authorizeResourceSlice(nodeName string, attrs authorizer.Attributes) (authorizer.Decision, string, error) {
	if len(attrs.GetSubresource()) > 0 {
		klog.V(2).Infof("NODE DENY: '%s' %#v", nodeName, attrs)
		return authorizer.DecisionNoOpinion, "cannot authorize ResourceSlice subresources", nil
	}

}

// NewPluginHandler returns new registration handler.
//
// Must only be called once per process because it manages global state.
// If a kubeClient is provided, then it synchronizes ResourceSlices
// with the resource information provided by plugins.
func NewRegistrationHandler(kubeClient kubernetes.Interface, getNode func() (*v1.Node, error)) *RegistrationHandler {
	handler := &RegistrationHandler{}

			var slices resourcev1alpha2informers.ResourceSliceInformer
			if utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) {
				slices = config.VersionedInformerFactory.Resource().V1alpha2().ResourceSlices()
			}
			node.RegisterMetrics()
			graph := node.NewGraph()
			node.AddGraphEventHandlers(
				graph,
				config.VersionedInformerFactory.Core().V1().Nodes(),

              ]
            },
            {
              "resource": "resourceslices",
              "responseKind": {
                "group": "",
                "kind": "ResourceSlice",
                "version": ""
              },
              "scope": "Cluster",
              "singularResource": "resourceslice",
              "verbs": [
                "create",
                "delete",