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

}

func (ResourceSlice) SwaggerDoc() map[string]string {
	return map_ResourceSlice
}

var map_ResourceSliceList = map[string]string{
	"":         "ResourceSliceList is a collection of ResourceSlices.",
	"metadata": "Standard list metadata",
	"items":    "Items is the list of node resource capacity objects.",
}

// ResourceSlice provides information about available
// resources on individual nodes.
type ResourceSlice struct {
	metav1.TypeMeta
	// Standard object metadata
	metav1.ObjectMeta

	// NodeName identifies the node which provides the resources
	// if they are local to a node.
	//
	// A field selector can be used to list only ResourceSlice
	// objects with a certain node name.

}

// ResourceSliceList is a collection of ResourceSlices.
message ResourceSliceList {
  // Standard list metadata
  // +optional
  optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is the list of node resource capacity objects.
  repeated ResourceSlice items = 2;
}

// StructuredResourceHandle is the in-tree representation of the allocation result.

	if a.GetOperation() == admission.Create {
		slice, ok := a.GetObject().(*resource.ResourceSlice)
		if !ok {
			return admission.NewForbidden(a, fmt.Errorf("unexpected type %T", a.GetObject()))
		}

		if slice.NodeName != nodeName {
			return admission.NewForbidden(a, errors.New("can only create ResourceSlice with the same NodeName as the requesting node"))
		}
	}

	return nil

// ResourceSliceList is a collection of ResourceSlices.
type ResourceSliceList struct {
	metav1.TypeMeta `json:",inline"`
	// Standard list metadata
	// +optional
	metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

	// Items is the list of node resource capacity objects.
	Items []ResourceSlice `json:"items" protobuf:"bytes,2,rep,name=items"`
}

// +genclient

			rbacv1helpers.NewRule(ReadUpdate...).Groups(legacyGroup).Resources("pods/finalizers").RuleOrDie(),
			rbacv1helpers.NewRule(Read...).Groups(resourceGroup).Resources("resourceslices", "resourceclassparameters", "resourceclaimparameters").RuleOrDie(),
		)
	}
	roles = append(roles, rbacv1.ClusterRole{
		// a role to use for the kube-scheduler

	// assigned to such a claim. Alternatively, claim allocation state
	// could also get tracked across pod scheduling cycles, but that
	// - adds complexity (need to carefully sync state with informer events
	//   for claims and ResourceSlices)
	// - would make integration with cluster autoscaler harder because it would need
	//   to trigger informer callbacks.
	//
	// When implementing cluster autoscaler support, this assume cache or

	apiResource := resourceapi.SchemeGroupVersion.WithResource("resourceslices")
	nodename := "mynode"
	mynode := &user.DefaultInfo{Name: "system:node:" + nodename, Groups: []string{"system:nodes"}}
	err := "can only create ResourceSlice with the same NodeName as the requesting node"

	sliceNode := &resourceapi.ResourceSlice{
		ObjectMeta: metav1.ObjectMeta{
			Name: "something",
		},

apiVersion: resource.k8s.io/v1alpha2
driverName: driverNameValue
kind: ResourceSlice
metadata:
  annotations:
    annotationsKey: annotationsValue
  creationTimestamp: "2008-01-01T01:01:01Z"
  deletionGracePeriodSeconds: 10
  deletionTimestamp: "2009-01-01T01:01:01Z"
  finalizers:
  - finalizersValue
  generateName: generateNameValue
  generation: 7
  labels:
    labelsKey: labelsValue
  managedFields:
  - apiVersion: apiVersionValue