DRA API: use DeviceCapacity struct instead of plain Quantity

This enables a future extension where capacity of a single device gets consumed
by different claims. The semantic without any additional fields is the same as
before: a capacity cannot be split up and is only an attribute of a device.

Because its semantically the same as before, two-way conversion to v1alpha3 is
possible.

pkg/apis/resource/types.go

@@ -214,7 +214,18 @@ type BasicDevice struct {
 	// The maximum number of attributes and capacities combined is 32.
 	//
 	// +optional
-	Capacity map[QualifiedName]resource.Quantity
+	Capacity map[QualifiedName]DeviceCapacity
+}
+
+// DeviceCapacity describes a quantity associated with a device.
+type DeviceCapacity struct {
+	// Quantity defines how much of a certain device capacity is available.
+	//
+	// +required
+	Quantity resource.Quantity
+
+	// potential future addition: fields which define how to "consume"
+	// capacity (= share a single device between different consumers).
 }
 
 // Limit for the sum of the number of entries in both attributes and capacity.

pkg/apis/resource/v1alpha3/conversion.go

@@ -19,8 +19,10 @@ package v1alpha3
 import (
 	"fmt"
 
-	resourceapi "k8s.io/api/resource/v1alpha3"
+	"k8s.io/apimachinery/pkg/api/resource"
+	conversion "k8s.io/apimachinery/pkg/conversion"
 	"k8s.io/apimachinery/pkg/runtime"
+	resourceapi "k8s.io/kubernetes/pkg/apis/resource"
 )
 
 func addConversionFuncs(scheme *runtime.Scheme) error {
@@ -38,3 +40,13 @@ func addConversionFuncs(scheme *runtime.Scheme) error {
 
 	return nil
 }
+
+func Convert_resource_DeviceCapacity_To_resource_Quantity(in *resourceapi.DeviceCapacity, out *resource.Quantity, s conversion.Scope) error {
+	*out = in.Quantity
+	return nil
+}
+
+func Convert_resource_Quantity_To_resource_DeviceCapacity(in *resource.Quantity, out *resourceapi.DeviceCapacity, s conversion.Scope) error {
+	out.Quantity = *in
+	return nil
+}

pkg/apis/resource/v1alpha3/zz_generated.conversion.go

@@ -351,6 +351,16 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddConversionFunc((*resource.DeviceCapacity)(nil), (*apiresource.Quantity)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_resource_DeviceCapacity_To_resource_Quantity(a.(*resource.DeviceCapacity), b.(*apiresource.Quantity), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddConversionFunc((*apiresource.Quantity)(nil), (*resource.DeviceCapacity)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_resource_Quantity_To_resource_DeviceCapacity(a.(*apiresource.Quantity), b.(*resource.DeviceCapacity), scope)
+	}); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -382,7 +392,19 @@ func Convert_resource_AllocationResult_To_v1alpha3_AllocationResult(in *resource
 
 func autoConvert_v1alpha3_BasicDevice_To_resource_BasicDevice(in *resourcev1alpha3.BasicDevice, out *resource.BasicDevice, s conversion.Scope) error {
 	out.Attributes = *(*map[resource.QualifiedName]resource.DeviceAttribute)(unsafe.Pointer(&in.Attributes))
-	out.Capacity = *(*map[resource.QualifiedName]apiresource.Quantity)(unsafe.Pointer(&in.Capacity))
+	if in.Capacity != nil {
+		in, out := &in.Capacity, &out.Capacity
+		*out = make(map[resource.QualifiedName]resource.DeviceCapacity, len(*in))
+		for key, val := range *in {
+			newVal := new(resource.DeviceCapacity)
+			if err := Convert_resource_Quantity_To_resource_DeviceCapacity(&val, newVal, s); err != nil {
+				return err
+			}
+			(*out)[resource.QualifiedName(key)] = *newVal
+		}
+	} else {
+		out.Capacity = nil
+	}
 	return nil
 }
 
@@ -393,7 +415,19 @@ func Convert_v1alpha3_BasicDevice_To_resource_BasicDevice(in *resourcev1alpha3.B
 
 func autoConvert_resource_BasicDevice_To_v1alpha3_BasicDevice(in *resource.BasicDevice, out *resourcev1alpha3.BasicDevice, s conversion.Scope) error {
 	out.Attributes = *(*map[resourcev1alpha3.QualifiedName]resourcev1alpha3.DeviceAttribute)(unsafe.Pointer(&in.Attributes))
-	out.Capacity = *(*map[resourcev1alpha3.QualifiedName]apiresource.Quantity)(unsafe.Pointer(&in.Capacity))
+	if in.Capacity != nil {
+		in, out := &in.Capacity, &out.Capacity
+		*out = make(map[resourcev1alpha3.QualifiedName]apiresource.Quantity, len(*in))
+		for key, val := range *in {
+			newVal := new(apiresource.Quantity)
+			if err := Convert_resource_DeviceCapacity_To_resource_Quantity(&val, newVal, s); err != nil {
+				return err
+			}
+			(*out)[resourcev1alpha3.QualifiedName(key)] = *newVal
+		}
+	} else {
+		out.Capacity = nil
+	}
 	return nil
 }
 
@@ -424,7 +458,15 @@ func Convert_resource_CELDeviceSelector_To_v1alpha3_CELDeviceSelector(in *resour
 
 func autoConvert_v1alpha3_Device_To_resource_Device(in *resourcev1alpha3.Device, out *resource.Device, s conversion.Scope) error {
 	out.Name = in.Name
-	out.Basic = (*resource.BasicDevice)(unsafe.Pointer(in.Basic))
+	if in.Basic != nil {
+		in, out := &in.Basic, &out.Basic
+		*out = new(resource.BasicDevice)
+		if err := Convert_v1alpha3_BasicDevice_To_resource_BasicDevice(*in, *out, s); err != nil {
+			return err
+		}
+	} else {
+		out.Basic = nil
+	}
 	return nil
 }
 
@@ -435,7 +477,15 @@ func Convert_v1alpha3_Device_To_resource_Device(in *resourcev1alpha3.Device, out
 
 func autoConvert_resource_Device_To_v1alpha3_Device(in *resource.Device, out *resourcev1alpha3.Device, s conversion.Scope) error {
 	out.Name = in.Name
-	out.Basic = (*resourcev1alpha3.BasicDevice)(unsafe.Pointer(in.Basic))
+	if in.Basic != nil {
+		in, out := &in.Basic, &out.Basic
+		*out = new(resourcev1alpha3.BasicDevice)
+		if err := Convert_resource_BasicDevice_To_v1alpha3_BasicDevice(*in, *out, s); err != nil {
+			return err
+		}
+	} else {
+		out.Basic = nil
+	}
 	return nil
 }
 
@@ -1058,7 +1108,17 @@ func Convert_resource_ResourceSlice_To_v1alpha3_ResourceSlice(in *resource.Resou
 
 func autoConvert_v1alpha3_ResourceSliceList_To_resource_ResourceSliceList(in *resourcev1alpha3.ResourceSliceList, out *resource.ResourceSliceList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	out.Items = *(*[]resource.ResourceSlice)(unsafe.Pointer(&in.Items))
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]resource.ResourceSlice, len(*in))
+		for i := range *in {
+			if err := Convert_v1alpha3_ResourceSlice_To_resource_ResourceSlice(&(*in)[i], &(*out)[i], s); err != nil {
+				return err
+			}
+		}
+	} else {
+		out.Items = nil
+	}
 	return nil
 }
 
@@ -1069,7 +1129,17 @@ func Convert_v1alpha3_ResourceSliceList_To_resource_ResourceSliceList(in *resour
 
 func autoConvert_resource_ResourceSliceList_To_v1alpha3_ResourceSliceList(in *resource.ResourceSliceList, out *resourcev1alpha3.ResourceSliceList, s conversion.Scope) error {
 	out.ListMeta = in.ListMeta
-	out.Items = *(*[]resourcev1alpha3.ResourceSlice)(unsafe.Pointer(&in.Items))
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]resourcev1alpha3.ResourceSlice, len(*in))
+		for i := range *in {
+			if err := Convert_resource_ResourceSlice_To_v1alpha3_ResourceSlice(&(*in)[i], &(*out)[i], s); err != nil {
+				return err
+			}
+		}
+	} else {
+		out.Items = nil
+	}
 	return nil
 }
 
@@ -1086,7 +1156,17 @@ func autoConvert_v1alpha3_ResourceSliceSpec_To_resource_ResourceSliceSpec(in *re
 	out.NodeName = in.NodeName
 	out.NodeSelector = (*core.NodeSelector)(unsafe.Pointer(in.NodeSelector))
 	out.AllNodes = in.AllNodes
-	out.Devices = *(*[]resource.Device)(unsafe.Pointer(&in.Devices))
+	if in.Devices != nil {
+		in, out := &in.Devices, &out.Devices
+		*out = make([]resource.Device, len(*in))
+		for i := range *in {
+			if err := Convert_v1alpha3_Device_To_resource_Device(&(*in)[i], &(*out)[i], s); err != nil {
+				return err
+			}
+		}
+	} else {
+		out.Devices = nil
+	}
 	return nil
 }
 
@@ -1103,7 +1183,17 @@ func autoConvert_resource_ResourceSliceSpec_To_v1alpha3_ResourceSliceSpec(in *re
 	out.NodeName = in.NodeName
 	out.NodeSelector = (*v1.NodeSelector)(unsafe.Pointer(in.NodeSelector))
 	out.AllNodes = in.AllNodes
-	out.Devices = *(*[]resourcev1alpha3.Device)(unsafe.Pointer(&in.Devices))
+	if in.Devices != nil {
+		in, out := &in.Devices, &out.Devices
+		*out = make([]resourcev1alpha3.Device, len(*in))
+		for i := range *in {
+			if err := Convert_resource_Device_To_v1alpha3_Device(&(*in)[i], &(*out)[i], s); err != nil {
+				return err
+			}
+		}
+	} else {
+		out.Devices = nil
+	}
 	return nil
 }
 

pkg/apis/resource/v1beta1/zz_generated.conversion.go

@@ -26,7 +26,6 @@ import (
 
 	v1 "k8s.io/api/core/v1"
 	resourcev1beta1 "k8s.io/api/resource/v1beta1"
-	apiresource "k8s.io/apimachinery/pkg/api/resource"
 	conversion "k8s.io/apimachinery/pkg/conversion"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	types "k8s.io/apimachinery/pkg/types"
@@ -111,6 +110,16 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddGeneratedConversionFunc((*resourcev1beta1.DeviceCapacity)(nil), (*resource.DeviceCapacity)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_v1beta1_DeviceCapacity_To_resource_DeviceCapacity(a.(*resourcev1beta1.DeviceCapacity), b.(*resource.DeviceCapacity), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddGeneratedConversionFunc((*resource.DeviceCapacity)(nil), (*resourcev1beta1.DeviceCapacity)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_resource_DeviceCapacity_To_v1beta1_DeviceCapacity(a.(*resource.DeviceCapacity), b.(*resourcev1beta1.DeviceCapacity), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddGeneratedConversionFunc((*resourcev1beta1.DeviceClaim)(nil), (*resource.DeviceClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_v1beta1_DeviceClaim_To_resource_DeviceClaim(a.(*resourcev1beta1.DeviceClaim), b.(*resource.DeviceClaim), scope)
 	}); err != nil {
@@ -382,7 +391,7 @@ func Convert_resource_AllocationResult_To_v1beta1_AllocationResult(in *resource.
 
 func autoConvert_v1beta1_BasicDevice_To_resource_BasicDevice(in *resourcev1beta1.BasicDevice, out *resource.BasicDevice, s conversion.Scope) error {
 	out.Attributes = *(*map[resource.QualifiedName]resource.DeviceAttribute)(unsafe.Pointer(&in.Attributes))
-	out.Capacity = *(*map[resource.QualifiedName]apiresource.Quantity)(unsafe.Pointer(&in.Capacity))
+	out.Capacity = *(*map[resource.QualifiedName]resource.DeviceCapacity)(unsafe.Pointer(&in.Capacity))
 	return nil
 }
 
@@ -393,7 +402,7 @@ func Convert_v1beta1_BasicDevice_To_resource_BasicDevice(in *resourcev1beta1.Bas
 
 func autoConvert_resource_BasicDevice_To_v1beta1_BasicDevice(in *resource.BasicDevice, out *resourcev1beta1.BasicDevice, s conversion.Scope) error {
 	out.Attributes = *(*map[resourcev1beta1.QualifiedName]resourcev1beta1.DeviceAttribute)(unsafe.Pointer(&in.Attributes))
-	out.Capacity = *(*map[resourcev1beta1.QualifiedName]apiresource.Quantity)(unsafe.Pointer(&in.Capacity))
+	out.Capacity = *(*map[resourcev1beta1.QualifiedName]resourcev1beta1.DeviceCapacity)(unsafe.Pointer(&in.Capacity))
 	return nil
 }
 
@@ -520,6 +529,26 @@ func Convert_resource_DeviceAttribute_To_v1beta1_DeviceAttribute(in *resource.De
 	return autoConvert_resource_DeviceAttribute_To_v1beta1_DeviceAttribute(in, out, s)
 }
 
+func autoConvert_v1beta1_DeviceCapacity_To_resource_DeviceCapacity(in *resourcev1beta1.DeviceCapacity, out *resource.DeviceCapacity, s conversion.Scope) error {
+	out.Quantity = in.Quantity
+	return nil
+}
+
+// Convert_v1beta1_DeviceCapacity_To_resource_DeviceCapacity is an autogenerated conversion function.
+func Convert_v1beta1_DeviceCapacity_To_resource_DeviceCapacity(in *resourcev1beta1.DeviceCapacity, out *resource.DeviceCapacity, s conversion.Scope) error {
+	return autoConvert_v1beta1_DeviceCapacity_To_resource_DeviceCapacity(in, out, s)
+}
+
+func autoConvert_resource_DeviceCapacity_To_v1beta1_DeviceCapacity(in *resource.DeviceCapacity, out *resourcev1beta1.DeviceCapacity, s conversion.Scope) error {
+	out.Quantity = in.Quantity
+	return nil
+}
+
+// Convert_resource_DeviceCapacity_To_v1beta1_DeviceCapacity is an autogenerated conversion function.
+func Convert_resource_DeviceCapacity_To_v1beta1_DeviceCapacity(in *resource.DeviceCapacity, out *resourcev1beta1.DeviceCapacity, s conversion.Scope) error {
+	return autoConvert_resource_DeviceCapacity_To_v1beta1_DeviceCapacity(in, out, s)
+}
+
 func autoConvert_v1beta1_DeviceClaim_To_resource_DeviceClaim(in *resourcev1beta1.DeviceClaim, out *resource.DeviceClaim, s conversion.Scope) error {
 	out.Requests = *(*[]resource.DeviceRequest)(unsafe.Pointer(&in.Requests))
 	out.Constraints = *(*[]resource.DeviceConstraint)(unsafe.Pointer(&in.Constraints))

pkg/apis/resource/validation/validation.go

@@ -24,7 +24,6 @@ import (
 	"strings"
 
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
-	apiresource "k8s.io/apimachinery/pkg/api/resource"
 	apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -523,7 +522,7 @@ func validateBasicDevice(device resource.BasicDevice, fldPath *field.Path) field
 	// field is too large, then so is the combination.
 	maxKeyLen := resource.DeviceMaxDomainLength + 1 + resource.DeviceMaxIDLength
 	allErrs = append(allErrs, validateMap(device.Attributes, -1, maxKeyLen, validateQualifiedName, validateDeviceAttribute, fldPath.Child("attributes"))...)
-	allErrs = append(allErrs, validateMap(device.Capacity, -1, maxKeyLen, validateQualifiedName, validateQuantity, fldPath.Child("capacity"))...)
+	allErrs = append(allErrs, validateMap(device.Capacity, -1, maxKeyLen, validateQualifiedName, validateDeviceCapacity, fldPath.Child("capacity"))...)
 	if combinedLen, max := len(device.Attributes)+len(device.Capacity), resource.ResourceSliceMaxAttributesAndCapacitiesPerDevice; combinedLen > max {
 		allErrs = append(allErrs, field.Invalid(fldPath, combinedLen, fmt.Sprintf("the total number of attributes and capacities must not exceed %d", max)))
 	}
@@ -587,7 +586,7 @@ func validateDeviceAttribute(attribute resource.DeviceAttribute, fldPath *field.
 	return allErrs
 }
 
-func validateQuantity(quantity apiresource.Quantity, fldPath *field.Path) field.ErrorList {
+func validateDeviceCapacity(capacity resource.DeviceCapacity, fldPath *field.Path) field.ErrorList {
 	// Any parsed quantity is valid.
 	return nil
 }

pkg/apis/resource/validation/validation_resourceslice_test.go

@@ -38,9 +38,9 @@ func testAttributes() map[resourceapi.QualifiedName]resourceapi.DeviceAttribute
 	}
 }
 
-func testCapacity() map[resourceapi.QualifiedName]resource.Quantity {
+func testCapacity() map[resourceapi.QualifiedName]resourceapi.DeviceCapacity {
-	return map[resourceapi.QualifiedName]resource.Quantity{
+	return map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{
-		"memory": resource.MustParse("1Gi"),
+		"memory": {Quantity: resource.MustParse("1Gi")},
 	}
 }
 
@@ -411,20 +411,21 @@ func TestValidateResourceSlice(t *testing.T) {
 			slice: func() *resourceapi.ResourceSlice {
 				slice := testResourceSlice(goodName, goodName, goodName, 3)
 				slice.Spec.Devices[0].Basic.Attributes = map[resourceapi.QualifiedName]resourceapi.DeviceAttribute{}
-				slice.Spec.Devices[0].Basic.Capacity = map[resourceapi.QualifiedName]resource.Quantity{}
+				slice.Spec.Devices[0].Basic.Capacity = map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{}
 				for i := 0; i < resourceapi.ResourceSliceMaxAttributesAndCapacitiesPerDevice; i++ {
 					slice.Spec.Devices[0].Basic.Attributes[resourceapi.QualifiedName(fmt.Sprintf("attr_%d", i))] = resourceapi.DeviceAttribute{StringValue: ptr.To("x")}
 				}
 				slice.Spec.Devices[1].Basic.Attributes = map[resourceapi.QualifiedName]resourceapi.DeviceAttribute{}
-				slice.Spec.Devices[1].Basic.Capacity = map[resourceapi.QualifiedName]resource.Quantity{}
+				slice.Spec.Devices[1].Basic.Capacity = map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{}
 				quantity := resource.MustParse("1Gi")
+				capacity := resourceapi.DeviceCapacity{Quantity: quantity}
 				for i := 0; i < resourceapi.ResourceSliceMaxAttributesAndCapacitiesPerDevice; i++ {
-					slice.Spec.Devices[1].Basic.Capacity[resourceapi.QualifiedName(fmt.Sprintf("cap_%d", i))] = quantity
+					slice.Spec.Devices[1].Basic.Capacity[resourceapi.QualifiedName(fmt.Sprintf("cap_%d", i))] = capacity
 				}
 				// Too large together by one.
 				slice.Spec.Devices[2].Basic.Attributes = slice.Spec.Devices[0].Basic.Attributes
-				slice.Spec.Devices[2].Basic.Capacity = map[resourceapi.QualifiedName]resource.Quantity{
+				slice.Spec.Devices[2].Basic.Capacity = map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{
-					"cap": quantity,
+					"cap": capacity,
 				}
 				return slice
 			}(),

pkg/apis/resource/zz_generated.deepcopy.go

@@ -22,7 +22,6 @@ limitations under the License.
 package resource
 
 import (
-	apiresource "k8s.io/apimachinery/pkg/api/resource"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	core "k8s.io/kubernetes/pkg/apis/core"
 )
@@ -61,9 +60,9 @@ func (in *BasicDevice) DeepCopyInto(out *BasicDevice) {
 	}
 	if in.Capacity != nil {
 		in, out := &in.Capacity, &out.Capacity
-		*out = make(map[QualifiedName]apiresource.Quantity, len(*in))
+		*out = make(map[QualifiedName]DeviceCapacity, len(*in))
 		for key, val := range *in {
-			(*out)[key] = val.DeepCopy()
+			(*out)[key] = *val.DeepCopy()
 		}
 	}
 	return
@@ -204,6 +203,23 @@ func (in *DeviceAttribute) DeepCopy() *DeviceAttribute {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *DeviceCapacity) DeepCopyInto(out *DeviceCapacity) {
+	*out = *in
+	out.Quantity = in.Quantity.DeepCopy()
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeviceCapacity.
+func (in *DeviceCapacity) DeepCopy() *DeviceCapacity {
+	if in == nil {
+		return nil
+	}
+	out := new(DeviceCapacity)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *DeviceClaim) DeepCopyInto(out *DeviceClaim) {
 	*out = *in

pkg/generated/openapi/zz_generated.openapi.go

@@ -938,6 +938,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA
 		"k8s.io/api/resource/v1beta1.DeviceAllocationConfiguration":                                             schema_k8sio_api_resource_v1beta1_DeviceAllocationConfiguration(ref),
 		"k8s.io/api/resource/v1beta1.DeviceAllocationResult":                                                    schema_k8sio_api_resource_v1beta1_DeviceAllocationResult(ref),
 		"k8s.io/api/resource/v1beta1.DeviceAttribute":                                                           schema_k8sio_api_resource_v1beta1_DeviceAttribute(ref),
+		"k8s.io/api/resource/v1beta1.DeviceCapacity":                                                            schema_k8sio_api_resource_v1beta1_DeviceCapacity(ref),
 		"k8s.io/api/resource/v1beta1.DeviceClaim":                                                               schema_k8sio_api_resource_v1beta1_DeviceClaim(ref),
 		"k8s.io/api/resource/v1beta1.DeviceClaimConfiguration":                                                  schema_k8sio_api_resource_v1beta1_DeviceClaimConfiguration(ref),
 		"k8s.io/api/resource/v1beta1.DeviceClass":                                                               schema_k8sio_api_resource_v1beta1_DeviceClass(ref),
@@ -47673,7 +47674,8 @@ func schema_k8sio_api_resource_v1beta1_BasicDevice(ref common.ReferenceCallback)
 								Allows: true,
 								Schema: &spec.Schema{
 									SchemaProps: spec.SchemaProps{
-										Ref: ref("k8s.io/apimachinery/pkg/api/resource.Quantity"),
+										Default: map[string]interface{}{},
+										Ref:     ref("k8s.io/api/resource/v1beta1.DeviceCapacity"),
 									},
 								},
 							},
@@ -47683,7 +47685,7 @@ func schema_k8sio_api_resource_v1beta1_BasicDevice(ref common.ReferenceCallback)
 			},
 		},
 		Dependencies: []string{
-			"k8s.io/api/resource/v1beta1.DeviceAttribute", "k8s.io/apimachinery/pkg/api/resource.Quantity"},
+			"k8s.io/api/resource/v1beta1.DeviceAttribute", "k8s.io/api/resource/v1beta1.DeviceCapacity"},
 	}
 }
 
@@ -47883,6 +47885,28 @@ func schema_k8sio_api_resource_v1beta1_DeviceAttribute(ref common.ReferenceCallb
 	}
 }
 
+func schema_k8sio_api_resource_v1beta1_DeviceCapacity(ref common.ReferenceCallback) common.OpenAPIDefinition {
+	return common.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Description: "DeviceCapacity describes a quantity associated with a device.",
+				Type:        []string{"object"},
+				Properties: map[string]spec.Schema{
+					"quantity": {
+						SchemaProps: spec.SchemaProps{
+							Description: "Quantity defines how much of a certain device capacity is available.",
+							Ref:         ref("k8s.io/apimachinery/pkg/api/resource.Quantity"),
+						},
+					},
+				},
+				Required: []string{"quantity"},
+			},
+		},
+		Dependencies: []string{
+			"k8s.io/apimachinery/pkg/api/resource.Quantity"},
+	}
+}
+
 func schema_k8sio_api_resource_v1beta1_DeviceClaim(ref common.ReferenceCallback) common.OpenAPIDefinition {
 	return common.OpenAPIDefinition{
 		Schema: spec.Schema{

staging/src/k8s.io/api/resource/v1beta1/generated.pb.go

@@ -27,7 +27,6 @@ import (
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 	v1 "k8s.io/api/core/v1"
-	resource "k8s.io/apimachinery/pkg/api/resource"
 
 	math "math"
 	math_bits "math/bits"
@@ -244,10 +243,38 @@ func (m *DeviceAttribute) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DeviceAttribute proto.InternalMessageInfo
 
+func (m *DeviceCapacity) Reset()      { *m = DeviceCapacity{} }
+func (*DeviceCapacity) ProtoMessage() {}
+func (*DeviceCapacity) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ba331e3ec6484c27, []int{7}
+}
+func (m *DeviceCapacity) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DeviceCapacity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *DeviceCapacity) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeviceCapacity.Merge(m, src)
+}
+func (m *DeviceCapacity) XXX_Size() int {
+	return m.Size()
+}
+func (m *DeviceCapacity) XXX_DiscardUnknown() {
+	xxx_messageInfo_DeviceCapacity.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DeviceCapacity proto.InternalMessageInfo
+
 func (m *DeviceClaim) Reset()      { *m = DeviceClaim{} }
 func (*DeviceClaim) ProtoMessage() {}
 func (*DeviceClaim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{7}
+	return fileDescriptor_ba331e3ec6484c27, []int{8}
 }
 func (m *DeviceClaim) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -275,7 +302,7 @@ var xxx_messageInfo_DeviceClaim proto.InternalMessageInfo
 func (m *DeviceClaimConfiguration) Reset()      { *m = DeviceClaimConfiguration{} }
 func (*DeviceClaimConfiguration) ProtoMessage() {}
 func (*DeviceClaimConfiguration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{8}
+	return fileDescriptor_ba331e3ec6484c27, []int{9}
 }
 func (m *DeviceClaimConfiguration) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -303,7 +330,7 @@ var xxx_messageInfo_DeviceClaimConfiguration proto.InternalMessageInfo
 func (m *DeviceClass) Reset()      { *m = DeviceClass{} }
 func (*DeviceClass) ProtoMessage() {}
 func (*DeviceClass) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{9}
+	return fileDescriptor_ba331e3ec6484c27, []int{10}
 }
 func (m *DeviceClass) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -331,7 +358,7 @@ var xxx_messageInfo_DeviceClass proto.InternalMessageInfo
 func (m *DeviceClassConfiguration) Reset()      { *m = DeviceClassConfiguration{} }
 func (*DeviceClassConfiguration) ProtoMessage() {}
 func (*DeviceClassConfiguration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{10}
+	return fileDescriptor_ba331e3ec6484c27, []int{11}
 }
 func (m *DeviceClassConfiguration) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -359,7 +386,7 @@ var xxx_messageInfo_DeviceClassConfiguration proto.InternalMessageInfo
 func (m *DeviceClassList) Reset()      { *m = DeviceClassList{} }
 func (*DeviceClassList) ProtoMessage() {}
 func (*DeviceClassList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{11}
+	return fileDescriptor_ba331e3ec6484c27, []int{12}
 }
 func (m *DeviceClassList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -387,7 +414,7 @@ var xxx_messageInfo_DeviceClassList proto.InternalMessageInfo
 func (m *DeviceClassSpec) Reset()      { *m = DeviceClassSpec{} }
 func (*DeviceClassSpec) ProtoMessage() {}
 func (*DeviceClassSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{12}
+	return fileDescriptor_ba331e3ec6484c27, []int{13}
 }
 func (m *DeviceClassSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -415,7 +442,7 @@ var xxx_messageInfo_DeviceClassSpec proto.InternalMessageInfo
 func (m *DeviceConfiguration) Reset()      { *m = DeviceConfiguration{} }
 func (*DeviceConfiguration) ProtoMessage() {}
 func (*DeviceConfiguration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{13}
+	return fileDescriptor_ba331e3ec6484c27, []int{14}
 }
 func (m *DeviceConfiguration) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -443,7 +470,7 @@ var xxx_messageInfo_DeviceConfiguration proto.InternalMessageInfo
 func (m *DeviceConstraint) Reset()      { *m = DeviceConstraint{} }
 func (*DeviceConstraint) ProtoMessage() {}
 func (*DeviceConstraint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{14}
+	return fileDescriptor_ba331e3ec6484c27, []int{15}
 }
 func (m *DeviceConstraint) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -471,7 +498,7 @@ var xxx_messageInfo_DeviceConstraint proto.InternalMessageInfo
 func (m *DeviceRequest) Reset()      { *m = DeviceRequest{} }
 func (*DeviceRequest) ProtoMessage() {}
 func (*DeviceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{15}
+	return fileDescriptor_ba331e3ec6484c27, []int{16}
 }
 func (m *DeviceRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -499,7 +526,7 @@ var xxx_messageInfo_DeviceRequest proto.InternalMessageInfo
 func (m *DeviceRequestAllocationResult) Reset()      { *m = DeviceRequestAllocationResult{} }
 func (*DeviceRequestAllocationResult) ProtoMessage() {}
 func (*DeviceRequestAllocationResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{16}
+	return fileDescriptor_ba331e3ec6484c27, []int{17}
 }
 func (m *DeviceRequestAllocationResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -527,7 +554,7 @@ var xxx_messageInfo_DeviceRequestAllocationResult proto.InternalMessageInfo
 func (m *DeviceSelector) Reset()      { *m = DeviceSelector{} }
 func (*DeviceSelector) ProtoMessage() {}
 func (*DeviceSelector) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{17}
+	return fileDescriptor_ba331e3ec6484c27, []int{18}
 }
 func (m *DeviceSelector) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -555,7 +582,7 @@ var xxx_messageInfo_DeviceSelector proto.InternalMessageInfo
 func (m *OpaqueDeviceConfiguration) Reset()      { *m = OpaqueDeviceConfiguration{} }
 func (*OpaqueDeviceConfiguration) ProtoMessage() {}
 func (*OpaqueDeviceConfiguration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{18}
+	return fileDescriptor_ba331e3ec6484c27, []int{19}
 }
 func (m *OpaqueDeviceConfiguration) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -583,7 +610,7 @@ var xxx_messageInfo_OpaqueDeviceConfiguration proto.InternalMessageInfo
 func (m *ResourceClaim) Reset()      { *m = ResourceClaim{} }
 func (*ResourceClaim) ProtoMessage() {}
 func (*ResourceClaim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{19}
+	return fileDescriptor_ba331e3ec6484c27, []int{20}
 }
 func (m *ResourceClaim) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -611,7 +638,7 @@ var xxx_messageInfo_ResourceClaim proto.InternalMessageInfo
 func (m *ResourceClaimConsumerReference) Reset()      { *m = ResourceClaimConsumerReference{} }
 func (*ResourceClaimConsumerReference) ProtoMessage() {}
 func (*ResourceClaimConsumerReference) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{20}
+	return fileDescriptor_ba331e3ec6484c27, []int{21}
 }
 func (m *ResourceClaimConsumerReference) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -639,7 +666,7 @@ var xxx_messageInfo_ResourceClaimConsumerReference proto.InternalMessageInfo
 func (m *ResourceClaimList) Reset()      { *m = ResourceClaimList{} }
 func (*ResourceClaimList) ProtoMessage() {}
 func (*ResourceClaimList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{21}
+	return fileDescriptor_ba331e3ec6484c27, []int{22}
 }
 func (m *ResourceClaimList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -667,7 +694,7 @@ var xxx_messageInfo_ResourceClaimList proto.InternalMessageInfo
 func (m *ResourceClaimSpec) Reset()      { *m = ResourceClaimSpec{} }
 func (*ResourceClaimSpec) ProtoMessage() {}
 func (*ResourceClaimSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{22}
+	return fileDescriptor_ba331e3ec6484c27, []int{23}
 }
 func (m *ResourceClaimSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -695,7 +722,7 @@ var xxx_messageInfo_ResourceClaimSpec proto.InternalMessageInfo
 func (m *ResourceClaimStatus) Reset()      { *m = ResourceClaimStatus{} }
 func (*ResourceClaimStatus) ProtoMessage() {}
 func (*ResourceClaimStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{23}
+	return fileDescriptor_ba331e3ec6484c27, []int{24}
 }
 func (m *ResourceClaimStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -723,7 +750,7 @@ var xxx_messageInfo_ResourceClaimStatus proto.InternalMessageInfo
 func (m *ResourceClaimTemplate) Reset()      { *m = ResourceClaimTemplate{} }
 func (*ResourceClaimTemplate) ProtoMessage() {}
 func (*ResourceClaimTemplate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{24}
+	return fileDescriptor_ba331e3ec6484c27, []int{25}
 }
 func (m *ResourceClaimTemplate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -751,7 +778,7 @@ var xxx_messageInfo_ResourceClaimTemplate proto.InternalMessageInfo
 func (m *ResourceClaimTemplateList) Reset()      { *m = ResourceClaimTemplateList{} }
 func (*ResourceClaimTemplateList) ProtoMessage() {}
 func (*ResourceClaimTemplateList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{25}
+	return fileDescriptor_ba331e3ec6484c27, []int{26}
 }
 func (m *ResourceClaimTemplateList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -779,7 +806,7 @@ var xxx_messageInfo_ResourceClaimTemplateList proto.InternalMessageInfo
 func (m *ResourceClaimTemplateSpec) Reset()      { *m = ResourceClaimTemplateSpec{} }
 func (*ResourceClaimTemplateSpec) ProtoMessage() {}
 func (*ResourceClaimTemplateSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{26}
+	return fileDescriptor_ba331e3ec6484c27, []int{27}
 }
 func (m *ResourceClaimTemplateSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -807,7 +834,7 @@ var xxx_messageInfo_ResourceClaimTemplateSpec proto.InternalMessageInfo
 func (m *ResourcePool) Reset()      { *m = ResourcePool{} }
 func (*ResourcePool) ProtoMessage() {}
 func (*ResourcePool) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{27}
+	return fileDescriptor_ba331e3ec6484c27, []int{28}
 }
 func (m *ResourcePool) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -835,7 +862,7 @@ var xxx_messageInfo_ResourcePool proto.InternalMessageInfo
 func (m *ResourceSlice) Reset()      { *m = ResourceSlice{} }
 func (*ResourceSlice) ProtoMessage() {}
 func (*ResourceSlice) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{28}
+	return fileDescriptor_ba331e3ec6484c27, []int{29}
 }
 func (m *ResourceSlice) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -863,7 +890,7 @@ var xxx_messageInfo_ResourceSlice proto.InternalMessageInfo
 func (m *ResourceSliceList) Reset()      { *m = ResourceSliceList{} }
 func (*ResourceSliceList) ProtoMessage() {}
 func (*ResourceSliceList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{29}
+	return fileDescriptor_ba331e3ec6484c27, []int{30}
 }
 func (m *ResourceSliceList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -891,7 +918,7 @@ var xxx_messageInfo_ResourceSliceList proto.InternalMessageInfo
 func (m *ResourceSliceSpec) Reset()      { *m = ResourceSliceSpec{} }
 func (*ResourceSliceSpec) ProtoMessage() {}
 func (*ResourceSliceSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ba331e3ec6484c27, []int{30}
+	return fileDescriptor_ba331e3ec6484c27, []int{31}
 }
 func (m *ResourceSliceSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -920,12 +947,13 @@ func init() {
 	proto.RegisterType((*AllocationResult)(nil), "k8s.io.api.resource.v1beta1.AllocationResult")
 	proto.RegisterType((*BasicDevice)(nil), "k8s.io.api.resource.v1beta1.BasicDevice")
 	proto.RegisterMapType((map[QualifiedName]DeviceAttribute)(nil), "k8s.io.api.resource.v1beta1.BasicDevice.AttributesEntry")
-	proto.RegisterMapType((map[QualifiedName]resource.Quantity)(nil), "k8s.io.api.resource.v1beta1.BasicDevice.CapacityEntry")
+	proto.RegisterMapType((map[QualifiedName]DeviceCapacity)(nil), "k8s.io.api.resource.v1beta1.BasicDevice.CapacityEntry")
 	proto.RegisterType((*CELDeviceSelector)(nil), "k8s.io.api.resource.v1beta1.CELDeviceSelector")
 	proto.RegisterType((*Device)(nil), "k8s.io.api.resource.v1beta1.Device")
 	proto.RegisterType((*DeviceAllocationConfiguration)(nil), "k8s.io.api.resource.v1beta1.DeviceAllocationConfiguration")
 	proto.RegisterType((*DeviceAllocationResult)(nil), "k8s.io.api.resource.v1beta1.DeviceAllocationResult")
 	proto.RegisterType((*DeviceAttribute)(nil), "k8s.io.api.resource.v1beta1.DeviceAttribute")
+	proto.RegisterType((*DeviceCapacity)(nil), "k8s.io.api.resource.v1beta1.DeviceCapacity")
 	proto.RegisterType((*DeviceClaim)(nil), "k8s.io.api.resource.v1beta1.DeviceClaim")
 	proto.RegisterType((*DeviceClaimConfiguration)(nil), "k8s.io.api.resource.v1beta1.DeviceClaimConfiguration")
 	proto.RegisterType((*DeviceClass)(nil), "k8s.io.api.resource.v1beta1.DeviceClass")
@@ -957,122 +985,124 @@ func init() {
 }
 
 var fileDescriptor_ba331e3ec6484c27 = []byte{
-	// 1832 bytes of a gzipped FileDescriptorProto
+	// 1862 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x19, 0xcd, 0x6f, 0xdc, 0x58,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcb, 0x6f, 0x1c, 0x49,
-	0x3d, 0x1e, 0x67, 0x26, 0xc9, 0x6f, 0xf2, 0xd5, 0x57, 0x58, 0xb2, 0xa9, 0x98, 0x69, 0x5d, 0x09,
+	0x19, 0x77, 0xbb, 0xed, 0xf1, 0xf8, 0x1b, 0xbf, 0x52, 0x81, 0xc5, 0xeb, 0x88, 0x99, 0xa4, 0x23,
-	0x66, 0xbb, 0xad, 0xa7, 0x09, 0x50, 0x55, 0xe5, 0xc2, 0x38, 0xc9, 0x56, 0x81, 0x26, 0xcd, 0xbe,
+	0xc1, 0x6c, 0x36, 0xe9, 0x49, 0x0c, 0x44, 0x51, 0xb8, 0x30, 0xed, 0x78, 0x23, 0x43, 0xe2, 0x78,
-	0xb0, 0xa1, 0x5a, 0x76, 0x11, 0x6f, 0x3c, 0x2f, 0x13, 0x13, 0x8f, 0xed, 0xda, 0xcf, 0x61, 0x73,
+	0xcb, 0x6c, 0x88, 0x96, 0x5d, 0x44, 0x4d, 0x4f, 0x65, 0xdc, 0xb8, 0xa7, 0xbb, 0xd3, 0x5d, 0x6d,
-	0x40, 0xa0, 0x3d, 0xaf, 0x10, 0x77, 0xc4, 0x15, 0x09, 0x89, 0x03, 0x7f, 0x01, 0x48, 0x20, 0xa4,
+	0xd6, 0x07, 0x04, 0xda, 0xf3, 0x0a, 0x71, 0x47, 0x5c, 0x91, 0x90, 0x38, 0xf0, 0x17, 0x80, 0x04,
-	0x8a, 0x03, 0xac, 0xe0, 0xb2, 0x17, 0x06, 0x3a, 0x7b, 0xe1, 0xc6, 0x3d, 0x27, 0xe4, 0xe7, 0xe7,
+	0x42, 0x8a, 0x38, 0xc0, 0x0a, 0x2e, 0x2b, 0x0e, 0x03, 0x99, 0xbd, 0x70, 0xe3, 0x9e, 0x13, 0xaa,
-	0xcf, 0x19, 0x0f, 0x0e, 0x5a, 0xa2, 0xdd, 0xdb, 0xf8, 0xf7, 0xfd, 0xfd, 0xfb, 0xd9, 0x03, 0xaf,
+	0xea, 0xea, 0xe7, 0x4c, 0x0f, 0x6d, 0xb4, 0x58, 0xbb, 0xb7, 0xe9, 0xef, 0x5d, 0xdf, 0xa3, 0xbe,
-	0x9f, 0x3e, 0xf4, 0x54, 0xc3, 0x6e, 0x13, 0xc7, 0x68, 0xbb, 0xd4, 0xb3, 0x7d, 0x57, 0xa7, 0xed,
+	0x5f, 0xf7, 0xc0, 0xeb, 0xc7, 0x77, 0x02, 0xdd, 0x72, 0x3b, 0xc4, 0xb3, 0x3a, 0x3e, 0x0d, 0xdc,
-	0xb3, 0x8d, 0x2e, 0x65, 0x64, 0xa3, 0xdd, 0xa7, 0x16, 0x75, 0x09, 0xa3, 0x3d, 0xd5, 0x71, 0x6d,
+	0xd0, 0x37, 0x69, 0xe7, 0xe4, 0x56, 0x8f, 0x32, 0x72, 0xab, 0x33, 0xa0, 0x0e, 0xf5, 0x09, 0xa3,
-	0x66, 0xa3, 0x1b, 0x21, 0xb1, 0x4a, 0x1c, 0x43, 0x8d, 0x88, 0x55, 0x41, 0xbc, 0x7e, 0xaf, 0x6f,
+	0x7d, 0xdd, 0xf3, 0x5d, 0xe6, 0xa2, 0x4b, 0x91, 0xb0, 0x4e, 0x3c, 0x4b, 0x8f, 0x85, 0x75, 0x29,
-	0xb0, 0x13, 0xbf, 0xab, 0xea, 0xf6, 0xa0, 0xdd, 0xb7, 0xfb, 0x76, 0x9b, 0xf3, 0x74, 0xfd, 0x63,
+	0xbc, 0x75, 0x63, 0x60, 0xb1, 0xa3, 0xb0, 0xa7, 0x9b, 0xee, 0xb0, 0x33, 0x70, 0x07, 0x6e, 0x47,
-	0xfe, 0xc4, 0x1f, 0xf8, 0xaf, 0x50, 0xd6, 0xba, 0x92, 0x52, 0xac, 0xdb, 0x6e, 0xa0, 0x34, 0xaf,
+	0xe8, 0xf4, 0xc2, 0xa7, 0xe2, 0x49, 0x3c, 0x88, 0x5f, 0x91, 0xad, 0x2d, 0x2d, 0xe3, 0xd8, 0x74,
-	0x6f, 0xfd, 0xab, 0x09, 0xcd, 0x80, 0xe8, 0x27, 0x86, 0x45, 0xdd, 0xf3, 0xb6, 0x73, 0xda, 0xcf,
+	0x7d, 0xee, 0xb4, 0xe8, 0x6f, 0xeb, 0xab, 0xa9, 0xcc, 0x90, 0x98, 0x47, 0x96, 0x43, 0xfd, 0xd3,
-	0x5a, 0x7b, 0x19, 0x2e, 0xaf, 0x3d, 0xa0, 0x8c, 0x4c, 0xd2, 0xd5, 0x2e, 0xe2, 0x72, 0x7d, 0x8b,
+	0x8e, 0x77, 0x3c, 0xc8, 0x47, 0x7b, 0x16, 0xad, 0xa0, 0x33, 0xa4, 0x8c, 0x4c, 0xf3, 0xd5, 0x29,
-	0x19, 0x83, 0x71, 0x35, 0x0f, 0xfe, 0x1b, 0x83, 0xa7, 0x9f, 0xd0, 0x01, 0xc9, 0xf3, 0x29, 0x7f,
+	0xd3, 0xf2, 0x43, 0x87, 0x59, 0xc3, 0x49, 0x37, 0xb7, 0xff, 0x9b, 0x42, 0x60, 0x1e, 0xd1, 0x21,
-	0x92, 0x60, 0xb5, 0x63, 0x9a, 0xb6, 0x4e, 0x98, 0x61, 0x5b, 0x98, 0x7a, 0xbe, 0xc9, 0xd0, 0xf7,
+	0x29, 0xea, 0x69, 0x7f, 0x52, 0x60, 0xa3, 0x6b, 0xdb, 0xae, 0x49, 0x98, 0xe5, 0x3a, 0x98, 0x06,
-	0x60, 0xae, 0x47, 0xcf, 0x0c, 0x9d, 0x7a, 0x6b, 0xd2, 0x4d, 0xa9, 0x55, 0xdf, 0xfc, 0x8a, 0x3a,
+	0xa1, 0xcd, 0xd0, 0xf7, 0x60, 0xa9, 0x4f, 0x4f, 0x2c, 0x93, 0x06, 0x9b, 0xca, 0x65, 0xa5, 0xdd,
-	0x25, 0xd6, 0xea, 0x36, 0xa7, 0xcd, 0x4b, 0xd1, 0x56, 0x5e, 0x0c, 0x9b, 0x33, 0xa3, 0x61, 0x73,
+	0xd8, 0xfe, 0x8a, 0x3e, 0x23, 0xd7, 0xfa, 0x3d, 0x21, 0x5b, 0xb4, 0x62, 0xac, 0x3f, 0x1f, 0xb5,
-	0x2e, 0xc4, 0x7b, 0x38, 0x12, 0x8a, 0x8e, 0x60, 0xd1, 0xb2, 0x7b, 0xf4, 0x90, 0x9a, 0x54, 0x67,
+	0xe6, 0xc6, 0xa3, 0xd6, 0x52, 0xc4, 0x0f, 0x70, 0x6c, 0x14, 0x3d, 0x86, 0x15, 0xc7, 0xed, 0xd3,
-	0xb6, 0xbb, 0x26, 0x73, 0x25, 0x37, 0xd3, 0x4a, 0x82, 0x24, 0xa8, 0x67, 0x1b, 0xea, 0x7e, 0x8a,
+	0x43, 0x6a, 0x53, 0x93, 0xb9, 0xfe, 0xa6, 0x2a, 0x9c, 0x5c, 0xce, 0x3a, 0xe1, 0x45, 0xd0, 0x4f,
-	0x4e, 0x5b, 0x1d, 0x0d, 0x9b, 0x8b, 0x69, 0x08, 0xce, 0xc8, 0x51, 0xfe, 0x2e, 0x43, 0x5d, 0x23,
+	0x6e, 0xe9, 0xfb, 0x19, 0x39, 0x63, 0x63, 0x3c, 0x6a, 0xad, 0x64, 0x29, 0x38, 0x67, 0x47, 0xfb,
-	0x9e, 0xa1, 0x87, 0x1a, 0xd1, 0x8f, 0x00, 0x08, 0x63, 0xae, 0xd1, 0xf5, 0x19, 0x77, 0x45, 0x6e,
+	0xbb, 0x0a, 0x0d, 0x83, 0x04, 0x96, 0x19, 0x79, 0x44, 0x3f, 0x02, 0x20, 0x8c, 0xf9, 0x56, 0x2f,
-	0xd5, 0x37, 0x1f, 0x4e, 0x75, 0x25, 0xc5, 0xad, 0x76, 0x62, 0xd6, 0x1d, 0x8b, 0xb9, 0xe7, 0xda,
+	0x64, 0xe2, 0x28, 0x6a, 0xbb, 0xb1, 0x7d, 0x67, 0xe6, 0x51, 0x32, 0xda, 0x7a, 0x37, 0x51, 0xdd,
-	0x6d, 0xe1, 0x0f, 0x24, 0x88, 0xf7, 0xff, 0xd1, 0x5c, 0x7a, 0xd3, 0x27, 0xa6, 0x71, 0x6c, 0xd0,
+	0x75, 0x98, 0x7f, 0x6a, 0x5c, 0x95, 0xe7, 0x81, 0x94, 0xf1, 0xfe, 0x3f, 0x5a, 0xab, 0x6f, 0x86,
-	0xde, 0x3e, 0x19, 0x50, 0x9c, 0x52, 0x88, 0x7c, 0x98, 0xd7, 0x89, 0x43, 0x74, 0x83, 0x9d, 0xaf,
+	0xc4, 0xb6, 0x9e, 0x5a, 0xb4, 0xbf, 0x4f, 0x86, 0x14, 0x67, 0x1c, 0xa2, 0x10, 0xea, 0x26, 0xf1,
-	0x55, 0xb8, 0xf2, 0x07, 0xa5, 0x95, 0x6f, 0x09, 0xc6, 0x50, 0xf5, 0x2d, 0xa1, 0x7a, 0x3e, 0x02,
+	0x88, 0x69, 0xb1, 0xd3, 0xcd, 0x79, 0xe1, 0xfc, 0x76, 0x65, 0xe7, 0x3b, 0x52, 0x31, 0x72, 0x7d,
-	0x8f, 0x2b, 0x8e, 0x55, 0xad, 0x9f, 0xc2, 0x4a, 0xce, 0x74, 0xb4, 0x0a, 0xf2, 0x29, 0x3d, 0xe7,
+	0x45, 0xba, 0xae, 0xc7, 0xe4, 0x49, 0xc7, 0x89, 0xab, 0xad, 0x63, 0x58, 0x2f, 0x84, 0x8e, 0x36,
-	0xc9, 0x5c, 0xc0, 0xc1, 0x4f, 0xa4, 0x41, 0xf5, 0x8c, 0x98, 0x3e, 0x5d, 0xab, 0xf0, 0xd8, 0xdf,
+	0x40, 0x3d, 0xa6, 0xa7, 0xa2, 0x98, 0xcb, 0x98, 0xff, 0x44, 0x06, 0x2c, 0x9e, 0x10, 0x3b, 0xa4,
-	0x2d, 0x93, 0xe0, 0x48, 0x28, 0x0e, 0x59, 0x1f, 0x55, 0x1e, 0x4a, 0xeb, 0xa7, 0xb0, 0x94, 0x31,
+	0x9b, 0xf3, 0x22, 0xf7, 0xd7, 0xab, 0x14, 0x38, 0x36, 0x8a, 0x23, 0xd5, 0xbb, 0xf3, 0x77, 0x94,
-	0x75, 0x82, 0xaa, 0xed, 0xac, 0x2a, 0x35, 0xa5, 0x2a, 0x2e, 0x55, 0xd5, 0x39, 0xed, 0x67, 0x75,
+	0xad, 0x23, 0x58, 0xcd, 0x85, 0x3a, 0xc5, 0x55, 0x37, 0xef, 0xea, 0xf5, 0x0a, 0xae, 0x62, 0x93,
-	0xbf, 0xe9, 0x13, 0x8b, 0x19, 0xec, 0x3c, 0xa5, 0x4c, 0x79, 0x0c, 0xd7, 0xb6, 0x76, 0x9e, 0x84,
+	0x19, 0x4f, 0xda, 0x7d, 0xb8, 0xb0, 0xb3, 0xfb, 0x20, 0xe2, 0xc7, 0x15, 0x47, 0xdb, 0x00, 0xf4,
-	0xd6, 0x44, 0x49, 0x47, 0x9b, 0x00, 0xf4, 0x3d, 0xc7, 0xa5, 0x9e, 0x67, 0xd8, 0x56, 0xa8, 0x57,
+	0x3d, 0xcf, 0xa7, 0x41, 0x60, 0xb9, 0x4e, 0xe4, 0xd4, 0x40, 0x71, 0x9d, 0x76, 0x13, 0x0e, 0xce,
-	0x43, 0x51, 0xaa, 0x76, 0x62, 0x0c, 0x4e, 0x51, 0x29, 0x3e, 0xd4, 0x44, 0x89, 0xdc, 0x84, 0x59,
+	0x48, 0x69, 0x21, 0xd4, 0x64, 0x7f, 0x5c, 0x86, 0x05, 0x87, 0x0c, 0xa9, 0xd4, 0x5b, 0x91, 0x7a,
-	0x8b, 0x0c, 0xa8, 0xe0, 0x5b, 0x14, 0x7c, 0xb3, 0x3c, 0xa4, 0x1c, 0x83, 0x76, 0xa1, 0xda, 0x0d,
+	0x0b, 0x22, 0x9f, 0x82, 0x83, 0xf6, 0x60, 0xb1, 0xc7, 0xab, 0x22, 0x63, 0x6f, 0x57, 0xad, 0x9f,
-	0x12, 0x23, 0xcc, 0x6f, 0x95, 0x4d, 0xa1, 0xb6, 0x30, 0x1a, 0x36, 0xab, 0x1c, 0x80, 0x43, 0x09,
+	0xb1, 0x3c, 0x1e, 0xb5, 0x16, 0x05, 0x01, 0x47, 0x16, 0xb4, 0x0f, 0xe6, 0xe1, 0x8b, 0xc5, 0x49,
-	0xca, 0x07, 0x15, 0xf8, 0x62, 0xbe, 0x59, 0xb6, 0x6c, 0xeb, 0xd8, 0xe8, 0xfb, 0x2e, 0x7f, 0x40,
+	0xd9, 0x71, 0x9d, 0xa7, 0xd6, 0x20, 0xf4, 0xc5, 0x03, 0xfa, 0x06, 0xd4, 0x22, 0x8b, 0x32, 0xa0,
-	0xdf, 0x80, 0x5a, 0x28, 0x51, 0x18, 0xd4, 0x12, 0x06, 0xd5, 0x0e, 0x39, 0xf4, 0x62, 0xd8, 0x7c,
+	0xb6, 0x0c, 0xa8, 0x76, 0x28, 0xa8, 0x2f, 0x47, 0xad, 0x57, 0x8a, 0xaa, 0x11, 0x07, 0x4b, 0x3d,
-	0x25, 0xcf, 0x1a, 0x62, 0xb0, 0xe0, 0x43, 0x2d, 0x98, 0x77, 0xe9, 0x73, 0x9f, 0x7a, 0xcc, 0xe3,
+	0xd4, 0x86, 0xba, 0x4f, 0x9f, 0x85, 0x34, 0x60, 0x81, 0xe8, 0xb8, 0x65, 0x63, 0x85, 0x77, 0x0d,
-	0x45, 0xb7, 0xa0, 0x2d, 0x06, 0x85, 0x83, 0x05, 0x0c, 0xc7, 0x58, 0xf4, 0x63, 0xb8, 0x1e, 0x36,
+	0x96, 0x34, 0x9c, 0x70, 0xd1, 0x8f, 0xe1, 0x62, 0x34, 0x8d, 0xb9, 0x10, 0xe4, 0x24, 0xde, 0xac,
-	0x64, 0xc6, 0x04, 0xd1, 0x8c, 0xf7, 0x4b, 0x14, 0x44, 0x86, 0x4f, 0xbb, 0x21, 0x4c, 0xbd, 0x3e,
+	0x52, 0xa2, 0xac, 0x9e, 0x71, 0x49, 0x86, 0x7a, 0x71, 0x0a, 0x13, 0x4f, 0xf3, 0xa4, 0x7d, 0xac,
-	0x01, 0x89, 0x27, 0x69, 0x52, 0x3e, 0x96, 0xe0, 0x95, 0xc9, 0xb3, 0x03, 0x51, 0x98, 0x73, 0xf9,
+	0xc0, 0x2b, 0xd3, 0x2f, 0x0e, 0x44, 0x61, 0xc9, 0x17, 0xbf, 0xe2, 0x99, 0xbd, 0x5b, 0x21, 0x1e,
-	0xaf, 0xa8, 0x6d, 0x1f, 0x95, 0xb0, 0x47, 0xf8, 0x58, 0x3c, 0x88, 0xc2, 0x67, 0x0f, 0x47, 0xb2,
+	0x79, 0xc6, 0xf2, 0x5b, 0x28, 0x7a, 0x0e, 0x70, 0x6c, 0x1b, 0xf5, 0xa0, 0x66, 0x8a, 0x90, 0xe4,
-	0x51, 0x17, 0x6a, 0x3a, 0x37, 0x49, 0xf4, 0xe7, 0xa3, 0x4b, 0xcd, 0xb9, 0xac, 0xff, 0xcb, 0x51,
+	0x70, 0xde, 0x3d, 0xd3, 0x25, 0x97, 0x3f, 0xff, 0x5a, 0x5c, 0xaa, 0x88, 0x8c, 0xa5, 0x65, 0xed,
-	0xaa, 0x42, 0x30, 0x16, 0x92, 0x95, 0x5f, 0x49, 0xb0, 0x92, 0x6b, 0x20, 0xd4, 0x00, 0xd9, 0xb0,
+	0x57, 0x0a, 0xac, 0x17, 0xa6, 0x07, 0x35, 0x41, 0xb5, 0x1c, 0x26, 0x3a, 0x4a, 0x8d, 0xea, 0xb3,
-	0x18, 0xaf, 0x28, 0x39, 0xcc, 0xcf, 0xae, 0xc5, 0x8e, 0x82, 0x3a, 0xc7, 0x01, 0x02, 0xdd, 0x82,
+	0xe7, 0xb0, 0xc7, 0xbc, 0xcf, 0x31, 0x67, 0xa0, 0x2b, 0xb0, 0xd0, 0x73, 0x5d, 0x5b, 0xd4, 0xa2,
-	0xd9, 0xae, 0x6d, 0x9b, 0x3c, 0x17, 0xf3, 0xda, 0xd2, 0x68, 0xd8, 0x5c, 0xd0, 0x6c, 0xdb, 0x0c,
+	0x6e, 0xac, 0x8e, 0x47, 0xad, 0x65, 0xc3, 0x75, 0xed, 0x48, 0x42, 0xb0, 0xd0, 0x97, 0xa1, 0x16,
-	0x29, 0x38, 0x0a, 0x7d, 0x19, 0x6a, 0x1e, 0x73, 0x0d, 0xab, 0xbf, 0x36, 0xcb, 0x2b, 0x65, 0x65,
+	0x30, 0xdf, 0x72, 0x06, 0x9b, 0x0b, 0xa2, 0x53, 0xd6, 0xc7, 0xa3, 0x56, 0xe3, 0x50, 0x50, 0x22,
-	0x34, 0x6c, 0xd6, 0x0f, 0x39, 0x24, 0x24, 0x13, 0x68, 0x74, 0x07, 0xe6, 0xce, 0xa8, 0xcb, 0x9b,
+	0x31, 0xc9, 0x46, 0xd7, 0x60, 0xe9, 0x84, 0xfa, 0x62, 0x38, 0x16, 0x85, 0xa4, 0xb8, 0x42, 0x1f,
-	0xa3, 0xca, 0x29, 0xf9, 0x14, 0x3d, 0x0a, 0x41, 0x21, 0x69, 0x44, 0xa0, 0xfc, 0xba, 0x02, 0x75,
+	0x47, 0xa4, 0x48, 0x34, 0x16, 0xd0, 0x1c, 0x58, 0xcb, 0x4f, 0x1f, 0x7a, 0x07, 0xea, 0xcf, 0x42,
-	0x91, 0x3e, 0x93, 0x18, 0x03, 0xf4, 0x2c, 0x55, 0x4c, 0x61, 0x1e, 0xee, 0x94, 0xcf, 0x83, 0xb6,
+	0xe2, 0x30, 0x7e, 0x81, 0x45, 0x8b, 0x40, 0xcf, 0xe4, 0x28, 0xd9, 0x33, 0xba, 0x77, 0x3c, 0xc8,
-	0x1a, 0x4d, 0xad, 0x09, 0xc5, 0xd7, 0x83, 0xba, 0x6e, 0x5b, 0x1e, 0x73, 0x89, 0x61, 0x89, 0x4a,
+	0x27, 0xed, 0x4d, 0xa9, 0x65, 0x6c, 0xc4, 0x17, 0x57, 0x4c, 0xc1, 0x89, 0x45, 0xed, 0xd7, 0xf3,
-	0xad, 0x6f, 0xde, 0x2b, 0x57, 0x74, 0x82, 0x4b, 0xbb, 0x2e, 0xe4, 0xd7, 0x13, 0x98, 0x87, 0xd3,
+	0xd0, 0x90, 0x0e, 0x6d, 0x62, 0x0d, 0xd1, 0x93, 0x4c, 0xf3, 0x46, 0x75, 0xbf, 0x56, 0xbd, 0xee,
-	0x62, 0xd1, 0xbb, 0x71, 0x7e, 0x65, 0xae, 0xe0, 0x6b, 0x65, 0x14, 0x04, 0x9e, 0x97, 0x4b, 0xed,
+	0xa9, 0xa7, 0x29, 0xcd, 0xde, 0x87, 0x86, 0xe9, 0x3a, 0x01, 0xf3, 0x89, 0xe5, 0xc8, 0xc9, 0x68,
-	0x1f, 0x25, 0x58, 0x2b, 0x62, 0xca, 0x34, 0xa2, 0xf4, 0xbf, 0x34, 0x62, 0xe5, 0xca, 0x1a, 0xf1,
+	0x6c, 0xdf, 0xa8, 0xd6, 0xe4, 0x52, 0xcb, 0xb8, 0x28, 0xed, 0x37, 0x52, 0x5a, 0x80, 0xb3, 0x66,
-	0x77, 0x52, 0x2a, 0xed, 0x9e, 0x87, 0xbe, 0x0f, 0xf3, 0xc1, 0x61, 0xd2, 0x23, 0x8c, 0x88, 0x03,
+	0xd1, 0xbb, 0x49, 0x3f, 0xa9, 0xc2, 0xc1, 0xd7, 0xaa, 0x38, 0xe0, 0x27, 0xaf, 0xd6, 0x4a, 0x7f,
-	0xe0, 0xfe, 0xb4, 0xa1, 0xed, 0xa9, 0x01, 0x75, 0xb0, 0xad, 0x9f, 0x76, 0x7f, 0x40, 0x75, 0xb6,
+	0x54, 0x60, 0xb3, 0x4c, 0x29, 0x37, 0xf8, 0xca, 0xff, 0x32, 0xf8, 0xf3, 0xe7, 0x36, 0xf8, 0xbf,
-	0x47, 0x19, 0x49, 0x46, 0x70, 0x02, 0xc3, 0xb1, 0x54, 0xb4, 0x0f, 0xb3, 0x9e, 0x43, 0xf5, 0x4b,
+	0x53, 0x32, 0x65, 0x0f, 0x02, 0xf4, 0x7d, 0xa8, 0x73, 0x14, 0xd4, 0x27, 0x8c, 0xc8, 0x26, 0xbb,
-	0x6c, 0x1f, 0x6e, 0xd9, 0xa1, 0x43, 0xf5, 0x64, 0x48, 0x07, 0x4f, 0x98, 0xcb, 0x51, 0x7e, 0x9e,
+	0x39, 0xab, 0xc9, 0x02, 0x9d, 0x4b, 0x73, 0x68, 0xf0, 0xa8, 0xf7, 0x03, 0x6a, 0xb2, 0x87, 0x94,
-	0xce, 0x84, 0xe7, 0x65, 0x33, 0x51, 0x10, 0x5f, 0xe9, 0xca, 0xe2, 0xfb, 0xdb, 0x78, 0x04, 0x70,
+	0x91, 0xf4, 0xca, 0x4f, 0x69, 0x38, 0xb1, 0x8a, 0xf6, 0x61, 0x21, 0xf0, 0xa8, 0x79, 0x86, 0x55,
-	0xeb, 0x9e, 0x18, 0x1e, 0x43, 0xef, 0x8c, 0xc5, 0x58, 0x2d, 0x17, 0xe3, 0x80, 0x9b, 0x47, 0x38,
+	0x27, 0x22, 0x3b, 0xf4, 0xa8, 0x99, 0x2e, 0x05, 0xfe, 0x84, 0x85, 0x1d, 0xed, 0xe7, 0xd9, 0x4a,
-	0x6e, 0xaf, 0x08, 0x92, 0x8a, 0xef, 0x1e, 0x54, 0x0d, 0x46, 0x07, 0x51, 0x63, 0xb5, 0xca, 0x06,
+	0x04, 0x41, 0xbe, 0x12, 0x25, 0xf9, 0x55, 0xce, 0x2d, 0xbf, 0xbf, 0x4d, 0xae, 0x1c, 0x11, 0xdd,
-	0x58, 0x5b, 0x12, 0x42, 0xab, 0xbb, 0x01, 0x3b, 0x0e, 0xa5, 0x28, 0x7f, 0xce, 0x3a, 0x10, 0x04,
+	0x03, 0x2b, 0x60, 0x7c, 0x90, 0x0b, 0x39, 0xd6, 0xab, 0xe5, 0x98, 0x6b, 0x8b, 0x0c, 0x27, 0xe3,
-	0x1e, 0xbd, 0x03, 0x0b, 0x9e, 0xd8, 0xc1, 0xd1, 0x70, 0x78, 0xbd, 0x84, 0x9a, 0xf8, 0x98, 0xbb,
+	0x15, 0x53, 0x32, 0xf9, 0x7d, 0x08, 0x8b, 0x16, 0xa3, 0xc3, 0x78, 0xb0, 0xda, 0x55, 0x13, 0x6c,
-	0x26, 0x34, 0x2d, 0x44, 0x10, 0x0f, 0x27, 0x02, 0x53, 0x9d, 0x5b, 0xb9, 0x4c, 0xe7, 0xe6, 0x52,
+	0xac, 0x4a, 0xa3, 0x8b, 0x7b, 0x5c, 0x1d, 0x47, 0x56, 0xb4, 0x3f, 0xe7, 0x0f, 0xc0, 0x13, 0x8f,
-	0x5f, 0xd8, 0xb9, 0xcf, 0x61, 0x52, 0xf6, 0xd0, 0xdb, 0x50, 0xb3, 0x1d, 0xf2, 0xdc, 0xa7, 0x22,
+	0xde, 0x81, 0xe5, 0x40, 0xee, 0xfc, 0xf8, 0x72, 0xa8, 0x82, 0x23, 0x12, 0xe4, 0x78, 0x41, 0x7a,
-	0x25, 0xd3, 0xef, 0xb5, 0xa7, 0x9c, 0x74, 0x52, 0x89, 0x40, 0xa0, 0x32, 0x44, 0x63, 0x21, 0x51,
+	0x5a, 0x8e, 0x29, 0x01, 0x4e, 0x0d, 0x66, 0x26, 0x77, 0xfe, 0x2c, 0x93, 0x5b, 0x28, 0x7d, 0xe9,
-	0xf9, 0xa9, 0x04, 0xab, 0xf9, 0x11, 0x76, 0x89, 0x21, 0x71, 0x00, 0xcb, 0x03, 0xc2, 0xf4, 0x93,
+	0xe4, 0x3e, 0x83, 0x69, 0xd5, 0x43, 0x6f, 0x43, 0xcd, 0xf5, 0xc8, 0xb3, 0x90, 0xca, 0x92, 0xcc,
-	0x78, 0x89, 0xf0, 0xde, 0x59, 0xd0, 0x5a, 0xa3, 0x61, 0x73, 0x79, 0x2f, 0x83, 0xb9, 0x18, 0x36,
+	0x06, 0x87, 0x8f, 0x84, 0xe8, 0xb4, 0x16, 0x01, 0xee, 0x32, 0x62, 0x63, 0x69, 0x51, 0xfb, 0xa9,
-	0xd1, 0x1b, 0xbe, 0x69, 0x9e, 0x67, 0x2f, 0xc4, 0x1c, 0xbf, 0xf2, 0xbe, 0x0c, 0x4b, 0x99, 0x81,
+	0x02, 0x1b, 0xc5, 0x2b, 0xec, 0x0c, 0x97, 0xc4, 0x01, 0xac, 0x0d, 0x09, 0x33, 0x8f, 0x92, 0xa5,
-	0x5d, 0xe2, 0x18, 0xea, 0xc0, 0x4a, 0x2f, 0x89, 0x75, 0x80, 0x10, 0x66, 0x7c, 0x41, 0x10, 0xa7,
+	0x25, 0x66, 0x67, 0xd9, 0x68, 0x8f, 0x47, 0xad, 0xb5, 0x87, 0x39, 0xce, 0xcb, 0x51, 0x0b, 0xbd,
-	0xcb, 0x84, 0xf3, 0xe5, 0xe9, 0xb3, 0x75, 0x23, 0x7f, 0xd2, 0x75, 0x73, 0x04, 0xcb, 0x24, 0x5e,
+	0x11, 0xda, 0xf6, 0x69, 0x1e, 0x8e, 0x16, 0xf4, 0xb5, 0xf7, 0x55, 0x58, 0xcd, 0x5d, 0xd8, 0x15,
-	0xd0, 0x7b, 0x76, 0x8f, 0x8a, 0xf5, 0xa8, 0x0a, 0xae, 0xe5, 0x4e, 0x06, 0x7b, 0x31, 0x6c, 0x7e,
+	0xc0, 0x57, 0x17, 0xd6, 0xfb, 0x69, 0xae, 0x39, 0x43, 0x86, 0xf1, 0x05, 0x29, 0x9c, 0x6d, 0x13,
-	0x2e, 0xbf, 0xd6, 0x03, 0x38, 0xce, 0x49, 0x41, 0xb7, 0xa1, 0xaa, 0xdb, 0xbe, 0xc5, 0xf8, 0x0e,
+	0xa1, 0x57, 0x94, 0xcf, 0xf7, 0x8d, 0xfa, 0x49, 0xf7, 0xcd, 0x63, 0x58, 0x23, 0x09, 0x20, 0x78,
-	0x95, 0x93, 0x36, 0xd9, 0x0a, 0x80, 0x38, 0xc4, 0xa1, 0x0d, 0xa8, 0x93, 0xde, 0xc0, 0xb0, 0x3a,
+	0xe8, 0xf6, 0xa9, 0x5c, 0xc7, 0xba, 0xd4, 0x5a, 0xeb, 0xe6, 0xb8, 0x2f, 0x47, 0xad, 0xcf, 0x15,
-	0xba, 0x4e, 0x3d, 0x6f, 0xad, 0xc6, 0xb7, 0x37, 0x5f, 0xcc, 0x9d, 0x04, 0x8c, 0xd3, 0x34, 0xca,
+	0x61, 0x04, 0xa7, 0xe3, 0x82, 0x15, 0x74, 0x15, 0x16, 0x4d, 0x37, 0x74, 0x98, 0xd8, 0xd9, 0x6a,
-	0xbf, 0xa5, 0xe8, 0x24, 0x2c, 0xb8, 0x5e, 0xd0, 0x6b, 0xc1, 0x29, 0xc4, 0x51, 0x22, 0x2f, 0xa9,
+	0x3a, 0x26, 0x3b, 0x9c, 0x88, 0x23, 0x1e, 0xba, 0x05, 0x0d, 0xd2, 0x1f, 0x5a, 0x4e, 0xd7, 0x34,
-	0x73, 0x86, 0x83, 0x71, 0x84, 0x47, 0x5f, 0x82, 0x5a, 0xcf, 0x35, 0xce, 0xa8, 0x2b, 0x92, 0x12,
+	0x69, 0x10, 0x6c, 0xd6, 0x04, 0x5a, 0x10, 0x40, 0xa0, 0x9b, 0x92, 0x71, 0x56, 0x46, 0xfb, 0xb7,
-	0x57, 0xff, 0x36, 0x87, 0x62, 0x81, 0x0d, 0xf2, 0xec, 0x44, 0xe7, 0x45, 0x2a, 0xcf, 0x07, 0xb6,
+	0x12, 0x43, 0xd0, 0x12, 0xb4, 0x84, 0x5e, 0xe3, 0xd0, 0x4b, 0xb0, 0x64, 0x5d, 0x32, 0xf0, 0x49,
-	0x6d, 0x62, 0x8e, 0xe1, 0x92, 0xb8, 0x55, 0x22, 0x7c, 0x89, 0xa4, 0xd0, 0x56, 0x81, 0xcd, 0x7b,
+	0x90, 0x71, 0xcc, 0x47, 0x5f, 0x82, 0x5a, 0xdf, 0xb7, 0x4e, 0xa8, 0x2f, 0x8b, 0x92, 0x74, 0xff,
-	0x5c, 0x2d, 0xe1, 0xf1, 0x77, 0x61, 0x39, 0x77, 0xc1, 0xef, 0x82, 0xac, 0x53, 0x73, 0xc2, 0x14,
+	0x3d, 0x41, 0xc5, 0x92, 0xcb, 0xeb, 0xec, 0xc5, 0x70, 0x26, 0x53, 0xe7, 0x03, 0xd7, 0xb5, 0xb1,
-	0x1c, 0xaf, 0x85, 0xb1, 0xf3, 0x5f, 0x9b, 0x1b, 0x0d, 0x9b, 0xf2, 0xd6, 0xce, 0x13, 0x1c, 0xc8,
+	0xe0, 0x08, 0x4b, 0x22, 0x2a, 0x99, 0xbe, 0xd4, 0x52, 0x14, 0xab, 0xe4, 0x16, 0x4f, 0xbc, 0x58,
-	0x50, 0x7e, 0x29, 0xc1, 0xab, 0x85, 0x6d, 0x99, 0x8a, 0x8f, 0x34, 0x35, 0x3e, 0x04, 0xc0, 0x21,
+	0xe1, 0xc4, 0xdf, 0x8d, 0x31, 0x4d, 0xf2, 0xc6, 0xb0, 0x07, 0xaa, 0x49, 0xed, 0x29, 0xb7, 0xe0,
-	0x2e, 0x19, 0x50, 0x46, 0x5d, 0x4f, 0xec, 0xa8, 0x7b, 0x85, 0xd3, 0x59, 0xbc, 0x61, 0xab, 0x98,
+	0x64, 0x2f, 0x4c, 0xbc, 0x6e, 0x18, 0x4b, 0xe3, 0x51, 0x4b, 0xdd, 0xd9, 0x7d, 0x80, 0xb9, 0x0d,
-	0xfc, 0x70, 0xe7, 0x3d, 0x46, 0xad, 0xe0, 0x92, 0x4a, 0xd6, 0xdf, 0x41, 0x2c, 0x08, 0xa7, 0x84,
+	0xed, 0x97, 0x0a, 0xbc, 0x5a, 0x3a, 0x96, 0x99, 0xfc, 0x28, 0x33, 0xf3, 0x43, 0x00, 0x3c, 0xe2,
-	0x2a, 0xbf, 0xa8, 0xc0, 0x12, 0x16, 0xde, 0x85, 0xb7, 0xd6, 0xff, 0x7f, 0xe9, 0x1e, 0x64, 0x96,
+	0x93, 0x21, 0x65, 0xd4, 0x0f, 0xe4, 0x8e, 0xba, 0x51, 0x7a, 0x3b, 0xcb, 0xd7, 0x79, 0x1d, 0x93,
-	0xee, 0xf4, 0x40, 0x67, 0x6c, 0x2b, 0x5a, 0xbb, 0xe8, 0x59, 0x70, 0x84, 0x12, 0xe6, 0x7b, 0xa5,
+	0x1f, 0xee, 0xbe, 0xc7, 0xa8, 0xc3, 0x91, 0x5b, 0xba, 0xfe, 0x0e, 0x12, 0x43, 0x38, 0x63, 0x54,
-	0xde, 0x1a, 0xb2, 0x32, 0x39, 0x5f, 0x92, 0x82, 0xf0, 0x19, 0x0b, 0x79, 0xca, 0x48, 0x82, 0x46,
+	0xfb, 0xc5, 0x3c, 0xac, 0x62, 0x79, 0xba, 0x08, 0x6b, 0xfd, 0xff, 0x97, 0xee, 0x41, 0x6e, 0xe9,
-	0x86, 0x3e, 0x18, 0x9a, 0xfe, 0x80, 0xba, 0x98, 0x1e, 0x53, 0x97, 0x5a, 0x3a, 0x45, 0x77, 0x61,
+	0xce, 0x4e, 0x74, 0x2e, 0xb6, 0xb2, 0xb5, 0x8b, 0x9e, 0x70, 0xd0, 0x4b, 0x58, 0x18, 0x54, 0x7a,
-	0x9e, 0x38, 0xc6, 0x63, 0xd7, 0xf6, 0x1d, 0x91, 0xcf, 0x78, 0x23, 0x76, 0x0e, 0x76, 0x39, 0x1c,
+	0x4b, 0xc9, 0xdb, 0x14, 0x7a, 0x69, 0x09, 0xa2, 0x67, 0x2c, 0xed, 0x69, 0x63, 0x05, 0x9a, 0x39,
-	0xc7, 0x14, 0x01, 0x75, 0x64, 0x90, 0xa8, 0xfb, 0xd4, 0x79, 0x1a, 0xc2, 0x71, 0x4c, 0x11, 0x4f,
+	0x79, 0x7e, 0x69, 0x86, 0x43, 0xea, 0x63, 0xfa, 0x94, 0xfa, 0xd4, 0x31, 0x29, 0xba, 0x0e, 0x75,
-	0xc2, 0xd9, 0xc2, 0x49, 0xa8, 0x81, 0xec, 0x1b, 0x3d, 0x71, 0x52, 0xdf, 0x17, 0x04, 0xf2, 0x5b,
+	0xe2, 0x59, 0xf7, 0x7d, 0x37, 0xf4, 0x64, 0x3d, 0x93, 0x8d, 0xd8, 0x3d, 0xd8, 0x13, 0x74, 0x9c,
-	0xbb, 0xdb, 0x17, 0xc3, 0xe6, 0xad, 0xa2, 0x8f, 0x31, 0xec, 0xdc, 0xa1, 0x9e, 0xfa, 0xd6, 0xee,
+	0x48, 0x70, 0xe9, 0x38, 0x20, 0xd9, 0xf7, 0x19, 0x78, 0x1a, 0xd1, 0x71, 0x22, 0x91, 0xdc, 0x84,
-	0x36, 0x0e, 0x98, 0x95, 0xdf, 0x4b, 0x70, 0x2d, 0xe3, 0xe4, 0x15, 0x5c, 0x06, 0x4f, 0xb3, 0x97,
+	0x0b, 0xa5, 0x37, 0xa1, 0x01, 0x6a, 0x68, 0xf5, 0x25, 0x84, 0xbf, 0x29, 0x05, 0xd4, 0xb7, 0xf6,
-	0xc1, 0x9d, 0xf2, 0x19, 0x2b, 0xb8, 0x0d, 0x4e, 0x72, 0x3e, 0xf0, 0xe3, 0xe0, 0x30, 0xff, 0x05,
+	0xee, 0xbd, 0x1c, 0xb5, 0xae, 0x94, 0x7d, 0xf9, 0x61, 0xa7, 0x1e, 0x0d, 0xf4, 0xb7, 0xf6, 0xee,
-	0xa9, 0x55, 0xf6, 0xf2, 0x2e, 0xfe, 0x6c, 0xa4, 0xfc, 0x4b, 0x82, 0xeb, 0x13, 0x6a, 0x08, 0xbd,
+	0x61, 0xae, 0xac, 0xfd, 0x5e, 0x81, 0x0b, 0xb9, 0x43, 0x9e, 0x03, 0x32, 0x78, 0x94, 0x47, 0x06,
-	0x0b, 0x90, 0x4c, 0x6b, 0xa1, 0x6f, 0xfa, 0xab, 0xc4, 0xd8, 0x2b, 0xe2, 0x32, 0xff, 0xae, 0x93,
+	0xd7, 0xaa, 0x57, 0xac, 0x04, 0x1b, 0x1c, 0x15, 0xce, 0x20, 0xc0, 0xc1, 0x61, 0xf1, 0x73, 0x55,
-	0x40, 0x53, 0x02, 0x91, 0x0b, 0x75, 0x97, 0x7a, 0xd4, 0x3d, 0xa3, 0xbd, 0x37, 0x6c, 0x57, 0xc4,
+	0xbb, 0x2a, 0xf2, 0x2e, 0xff, 0x46, 0xa5, 0xfd, 0x4b, 0x81, 0x8b, 0x53, 0x7a, 0x08, 0xbd, 0x0b,
-	0xed, 0xeb, 0xe5, 0xe3, 0x36, 0x56, 0xb9, 0xc9, 0x8b, 0x0b, 0x4e, 0xe4, 0xe2, 0xb4, 0x12, 0xe5,
+	0x90, 0xde, 0xd6, 0xd2, 0xdf, 0xec, 0x57, 0x89, 0x89, 0x57, 0xd2, 0x35, 0xf1, 0x11, 0x29, 0xa5,
-	0x6f, 0x12, 0x7c, 0x3e, 0x23, 0xe4, 0xdb, 0x74, 0xe0, 0x98, 0x84, 0xd1, 0x2b, 0x18, 0x13, 0xcf,
+	0x66, 0x0c, 0x22, 0x1f, 0x1a, 0x3e, 0x0d, 0xa8, 0x7f, 0x42, 0xfb, 0x6f, 0xb8, 0xbe, 0xcc, 0xdb,
-	0x32, 0x63, 0xe2, 0x41, 0x79, 0x47, 0x23, 0x1b, 0x0b, 0xaf, 0xf4, 0xbf, 0x4a, 0xf0, 0xea, 0x44,
+	0xd7, 0xab, 0xe7, 0x6d, 0xa2, 0x73, 0xd3, 0x17, 0x17, 0x9c, 0xda, 0xc5, 0x59, 0x27, 0xda, 0xdf,
-	0x8e, 0x2b, 0xa8, 0xfb, 0xef, 0x64, 0xeb, 0x7e, 0xf3, 0xf2, 0x6e, 0x15, 0xd4, 0xff, 0x5f, 0x8a,
+	0x14, 0xf8, 0x7c, 0xce, 0xc8, 0xb7, 0xe9, 0xd0, 0xb3, 0x09, 0xa3, 0xe7, 0x70, 0x4d, 0x3c, 0xc9,
-	0x9c, 0xe2, 0x8d, 0xf0, 0x19, 0x9c, 0xea, 0xca, 0x6f, 0x24, 0x58, 0x8c, 0x28, 0x83, 0x9b, 0xa0,
+	0x5d, 0x13, 0xb7, 0xab, 0x1f, 0x34, 0x8e, 0xb1, 0x14, 0xa5, 0xff, 0x55, 0x81, 0x57, 0xa7, 0x6a,
-	0xc4, 0x5d, 0xb8, 0x09, 0x20, 0xbe, 0x2c, 0x47, 0x6f, 0xae, 0x72, 0x62, 0xf6, 0xe3, 0x18, 0x83,
+	0x9c, 0x43, 0xdf, 0x7f, 0x27, 0xdf, 0xf7, 0xdb, 0x67, 0x3f, 0x56, 0x49, 0xff, 0xff, 0xa5, 0xec,
-	0x53, 0x54, 0xe8, 0x9b, 0x80, 0x22, 0x03, 0x0f, 0x4d, 0xbe, 0xab, 0x83, 0xfb, 0x4a, 0xe6, 0xbc,
+	0x50, 0x62, 0x10, 0x3e, 0x83, 0xb7, 0xba, 0xf6, 0x1b, 0x05, 0x56, 0x62, 0x49, 0x8e, 0x09, 0x2a,
-	0xeb, 0x82, 0x17, 0xe1, 0x31, 0x0a, 0x3c, 0x81, 0x4b, 0xf9, 0x83, 0x94, 0xac, 0x53, 0x0e, 0xfe,
+	0xe0, 0xc2, 0x6d, 0x00, 0xf9, 0x19, 0x3b, 0x7e, 0x73, 0x55, 0xd3, 0xb0, 0xef, 0x27, 0x1c, 0x9c,
-	0x94, 0x06, 0x9e, 0xdb, 0x56, 0x18, 0xf8, 0xf4, 0x3e, 0xe0, 0x94, 0x9f, 0xd6, 0x7d, 0xc0, 0x8d,
+	0x91, 0x42, 0xdf, 0x04, 0x14, 0x07, 0x78, 0x68, 0x8b, 0x5d, 0xcd, 0xf1, 0x95, 0x2a, 0x74, 0xb7,
-	0x2b, 0xe8, 0x87, 0x0f, 0xe4, 0x9c, 0x13, 0xbc, 0x0f, 0xca, 0x9e, 0x5e, 0xdf, 0x12, 0xa7, 0x69,
+	0xa4, 0x2e, 0xc2, 0x13, 0x12, 0x78, 0x8a, 0x96, 0xf6, 0x07, 0x25, 0x5d, 0xa7, 0x82, 0xfc, 0x29,
-	0x18, 0xd4, 0xd7, 0x4a, 0x59, 0x13, 0xd4, 0xe8, 0xc4, 0x2b, 0xf6, 0x2e, 0xcc, 0x5b, 0x76, 0x8f,
+	0x4d, 0xbc, 0x88, 0xad, 0x34, 0xf1, 0xd9, 0x7d, 0x20, 0x24, 0x3f, 0xad, 0xfb, 0x40, 0x04, 0x57,
-	0xf2, 0xd7, 0x94, 0xdc, 0xce, 0xdf, 0x17, 0x70, 0x1c, 0x53, 0x8c, 0xfd, 0x2b, 0x31, 0xfb, 0xc9,
+	0x32, 0x0f, 0x1f, 0xa8, 0x85, 0x43, 0x88, 0x39, 0xa8, 0x0a, 0xbd, 0xbe, 0x25, 0xa1, 0x69, 0x94,
-	0xfc, 0x2b, 0xc1, 0xef, 0x14, 0xd3, 0x0c, 0x08, 0xa2, 0x03, 0x39, 0xb9, 0x53, 0x04, 0x1c, 0xc7,
+	0xd4, 0xd7, 0x2a, 0x45, 0xc3, 0x7b, 0x74, 0x2a, 0x8a, 0xbd, 0x0e, 0x75, 0xc7, 0xed, 0x53, 0xf1,
-	0x14, 0x68, 0x3f, 0xd9, 0x9c, 0x35, 0x9e, 0x91, 0xdb, 0x25, 0x36, 0x67, 0xf1, 0xd2, 0xd4, 0x3a,
+	0x9a, 0x52, 0xd8, 0xf9, 0xfb, 0x92, 0x8e, 0x13, 0x89, 0x89, 0xbf, 0x40, 0x16, 0x3e, 0x99, 0xbf,
-	0x2f, 0x5e, 0x36, 0x66, 0x3e, 0x7c, 0xd9, 0x98, 0xf9, 0xe8, 0x65, 0x63, 0xe6, 0x27, 0xa3, 0x86,
+	0x40, 0x04, 0x4e, 0xb1, 0x6d, 0x2e, 0x10, 0x03, 0xe4, 0x14, 0xa7, 0x48, 0x3a, 0x4e, 0x24, 0xd0,
-	0xf4, 0x62, 0xd4, 0x90, 0x3e, 0x1c, 0x35, 0xa4, 0x8f, 0x46, 0x0d, 0xe9, 0x9f, 0xa3, 0x86, 0xf4,
+	0x7e, 0xba, 0x39, 0x6b, 0xa2, 0x22, 0x57, 0x2b, 0x6c, 0xce, 0xf2, 0xa5, 0x69, 0x74, 0x9f, 0xbf,
-	0xb3, 0x8f, 0x1b, 0x33, 0x6f, 0xdf, 0x98, 0xf2, 0xc7, 0xdb, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff,
+	0x68, 0xce, 0x7d, 0xf8, 0xa2, 0x39, 0xf7, 0xd1, 0x8b, 0xe6, 0xdc, 0x4f, 0xc6, 0x4d, 0xe5, 0xf9,
-	0xb6, 0x94, 0xf6, 0xea, 0x96, 0x1b, 0x00, 0x00,
+	0xb8, 0xa9, 0x7c, 0x38, 0x6e, 0x2a, 0x1f, 0x8d, 0x9b, 0xca, 0x3f, 0xc7, 0x4d, 0xe5, 0x67, 0x1f,
+	0x37, 0xe7, 0xde, 0xbe, 0x34, 0xe3, 0x5f, 0xbe, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x42, 0x0c,
+	0x39, 0x8d, 0x03, 0x1c, 0x00, 0x00,
 }
 
 func (m *AllocationResult) Marshal() (dAtA []byte, err error) {
@@ -1419,6 +1449,39 @@ func (m *DeviceAttribute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *DeviceCapacity) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DeviceCapacity) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeviceCapacity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Quantity.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func (m *DeviceClaim) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2666,6 +2729,17 @@ func (m *DeviceAttribute) Size() (n int) {
 	return n
 }
 
+func (m *DeviceCapacity) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Quantity.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
 func (m *DeviceClaim) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3102,7 +3176,7 @@ func (this *BasicDevice) String() string {
 		keysForCapacity = append(keysForCapacity, string(k))
 	}
 	github_com_gogo_protobuf_sortkeys.Strings(keysForCapacity)
-	mapStringForCapacity := "map[QualifiedName]resource.Quantity{"
+	mapStringForCapacity := "map[QualifiedName]DeviceCapacity{"
 	for _, k := range keysForCapacity {
 		mapStringForCapacity += fmt.Sprintf("%v: %v,", k, this.Capacity[QualifiedName(k)])
 	}
@@ -3181,6 +3255,16 @@ func (this *DeviceAttribute) String() string {
 	}, "")
 	return s
 }
+func (this *DeviceCapacity) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&DeviceCapacity{`,
+		`Quantity:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Quantity), "Quantity", "resource.Quantity", 1), `&`, ``, 1) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *DeviceClaim) String() string {
 	if this == nil {
 		return "nil"
@@ -3832,10 +3916,10 @@ func (m *BasicDevice) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Capacity == nil {
-				m.Capacity = make(map[QualifiedName]resource.Quantity)
+				m.Capacity = make(map[QualifiedName]DeviceCapacity)
 			}
 			var mapkey QualifiedName
-			mapvalue := &resource.Quantity{}
+			mapvalue := &DeviceCapacity{}
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -3909,7 +3993,7 @@ func (m *BasicDevice) Unmarshal(dAtA []byte) error {
 					if postmsgIndex > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapvalue = &resource.Quantity{}
+					mapvalue = &DeviceCapacity{}
 					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 						return err
 					}
@@ -4574,6 +4658,89 @@ func (m *DeviceAttribute) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *DeviceCapacity) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DeviceCapacity: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DeviceCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Quantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *DeviceClaim) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

staging/src/k8s.io/api/resource/v1beta1/generated.proto

@@ -60,7 +60,7 @@ message BasicDevice {
   // The maximum number of attributes and capacities combined is 32.
   //
   // +optional
-  map<string, .k8s.io.apimachinery.pkg.api.resource.Quantity> capacity = 2;
+  map<string, DeviceCapacity> capacity = 2;
 }
 
 // CELDeviceSelector contains a CEL expression for selecting a device.
@@ -204,6 +204,14 @@ message DeviceAttribute {
   optional string version = 5;
 }
 
+// DeviceCapacity describes a quantity associated with a device.
+message DeviceCapacity {
+  // Quantity defines how much of a certain device capacity is available.
+  //
+  // +required
+  optional .k8s.io.apimachinery.pkg.api.resource.Quantity quantity = 1;
+}
+
 // DeviceClaim defines how to request devices with a ResourceClaim.
 message DeviceClaim {
   // Requests represent individual requests for distinct devices which

staging/src/k8s.io/api/resource/v1beta1/types.go

@@ -217,7 +217,18 @@ type BasicDevice struct {
 	// The maximum number of attributes and capacities combined is 32.
 	//
 	// +optional
-	Capacity map[QualifiedName]resource.Quantity `json:"capacity,omitempty" protobuf:"bytes,2,rep,name=capacity"`
+	Capacity map[QualifiedName]DeviceCapacity `json:"capacity,omitempty" protobuf:"bytes,2,rep,name=capacity"`
+}
+
+// DeviceCapacity describes a quantity associated with a device.
+type DeviceCapacity struct {
+	// Quantity defines how much of a certain device capacity is available.
+	//
+	// +required
+	Quantity resource.Quantity `json:"quantity" protobuf:"bytes,1,rep,name=quantity"`
+
+	// potential future addition: fields which define how to "consume"
+	// capacity (= share a single device between different consumers).
 }
 
 // Limit for the sum of the number of entries in both attributes and capacity.

staging/src/k8s.io/api/resource/v1beta1/types_swagger_doc_generated.go

@@ -98,6 +98,15 @@ func (DeviceAttribute) SwaggerDoc() map[string]string {
 	return map_DeviceAttribute
 }
 
+var map_DeviceCapacity = map[string]string{
+	"":         "DeviceCapacity describes a quantity associated with a device.",
+	"quantity": "Quantity defines how much of a certain device capacity is available.",
+}
+
+func (DeviceCapacity) SwaggerDoc() map[string]string {
+	return map_DeviceCapacity
+}
+
 var map_DeviceClaim = map[string]string{
 	"":            "DeviceClaim defines how to request devices with a ResourceClaim.",
 	"requests":    "Requests represent individual requests for distinct devices which must all be satisfied. If empty, nothing needs to be allocated.",

staging/src/k8s.io/api/resource/v1beta1/zz_generated.deepcopy.go

@@ -23,7 +23,6 @@ package v1beta1
 
 import (
 	v1 "k8s.io/api/core/v1"
-	resource "k8s.io/apimachinery/pkg/api/resource"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
@@ -61,9 +60,9 @@ func (in *BasicDevice) DeepCopyInto(out *BasicDevice) {
 	}
 	if in.Capacity != nil {
 		in, out := &in.Capacity, &out.Capacity
-		*out = make(map[QualifiedName]resource.Quantity, len(*in))
+		*out = make(map[QualifiedName]DeviceCapacity, len(*in))
 		for key, val := range *in {
-			(*out)[key] = val.DeepCopy()
+			(*out)[key] = *val.DeepCopy()
 		}
 	}
 	return
@@ -204,6 +203,23 @@ func (in *DeviceAttribute) DeepCopy() *DeviceAttribute {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *DeviceCapacity) DeepCopyInto(out *DeviceCapacity) {
+	*out = *in
+	out.Quantity = in.Quantity.DeepCopy()
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeviceCapacity.
+func (in *DeviceCapacity) DeepCopy() *DeviceCapacity {
+	if in == nil {
+		return nil
+	}
+	out := new(DeviceCapacity)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *DeviceClaim) DeepCopyInto(out *DeviceClaim) {
 	*out = *in

staging/src/k8s.io/api/testdata/HEAD/resource.k8s.io.v1beta1.ResourceSlice.json

@@ -89,7 +89,9 @@
             }
           },
           "capacity": {
-            "capacityKey": "0"
+            "capacityKey": {
+              "quantity": "0"
+            }
           }
         }
       }

staging/src/k8s.io/api/testdata/HEAD/resource.k8s.io.v1beta1.ResourceSlice.yaml

@@ -43,7 +43,8 @@ spec:
           string: stringValue
           version: versionValue
       capacity:
-        capacityKey: "0"
+        capacityKey:
+          quantity: "0"
     name: nameValue
   driver: driverValue
   nodeName: nodeNameValue

staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go

@@ -12754,7 +12754,7 @@ var schemaYAML = typed.YAMLObject(`types:
       type:
         map:
           elementType:
-            namedType: io.k8s.apimachinery.pkg.api.resource.Quantity
+            namedType: io.k8s.api.resource.v1beta1.DeviceCapacity
 - name: io.k8s.api.resource.v1beta1.CELDeviceSelector
   map:
     fields:
@@ -12818,6 +12818,12 @@ var schemaYAML = typed.YAMLObject(`types:
     - name: version
       type:
         scalar: string
+- name: io.k8s.api.resource.v1beta1.DeviceCapacity
+  map:
+    fields:
+    - name: quantity
+      type:
+        namedType: io.k8s.apimachinery.pkg.api.resource.Quantity
 - name: io.k8s.api.resource.v1beta1.DeviceClaim
   map:
     fields:

staging/src/k8s.io/client-go/applyconfigurations/resource/v1beta1/basicdevice.go

@@ -20,14 +20,13 @@ package v1beta1
 
 import (
 	resourcev1beta1 "k8s.io/api/resource/v1beta1"
-	resource "k8s.io/apimachinery/pkg/api/resource"
 )
 
 // BasicDeviceApplyConfiguration represents a declarative configuration of the BasicDevice type for use
 // with apply.
 type BasicDeviceApplyConfiguration struct {
 	Attributes map[resourcev1beta1.QualifiedName]DeviceAttributeApplyConfiguration `json:"attributes,omitempty"`
-	Capacity   map[resourcev1beta1.QualifiedName]resource.Quantity                 `json:"capacity,omitempty"`
+	Capacity   map[resourcev1beta1.QualifiedName]DeviceCapacityApplyConfiguration  `json:"capacity,omitempty"`
 }
 
 // BasicDeviceApplyConfiguration constructs a declarative configuration of the BasicDevice type for use with
@@ -54,9 +53,9 @@ func (b *BasicDeviceApplyConfiguration) WithAttributes(entries map[resourcev1bet
 // and returns the receiver, so that objects can be build by chaining "With" function invocations.
 // If called multiple times, the entries provided by each call will be put on the Capacity field,
 // overwriting an existing map entries in Capacity field with the same key.
-func (b *BasicDeviceApplyConfiguration) WithCapacity(entries map[resourcev1beta1.QualifiedName]resource.Quantity) *BasicDeviceApplyConfiguration {
+func (b *BasicDeviceApplyConfiguration) WithCapacity(entries map[resourcev1beta1.QualifiedName]DeviceCapacityApplyConfiguration) *BasicDeviceApplyConfiguration {
 	if b.Capacity == nil && len(entries) > 0 {
-		b.Capacity = make(map[resourcev1beta1.QualifiedName]resource.Quantity, len(entries))
+		b.Capacity = make(map[resourcev1beta1.QualifiedName]DeviceCapacityApplyConfiguration, len(entries))
 	}
 	for k, v := range entries {
 		b.Capacity[k] = v

staging/src/k8s.io/client-go/applyconfigurations/resource/v1beta1/devicecapacity.go

@@ -0,0 +1,43 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	resource "k8s.io/apimachinery/pkg/api/resource"
+)
+
+// DeviceCapacityApplyConfiguration represents a declarative configuration of the DeviceCapacity type for use
+// with apply.
+type DeviceCapacityApplyConfiguration struct {
+	Quantity *resource.Quantity `json:"quantity,omitempty"`
+}
+
+// DeviceCapacityApplyConfiguration constructs a declarative configuration of the DeviceCapacity type for use with
+// apply.
+func DeviceCapacity() *DeviceCapacityApplyConfiguration {
+	return &DeviceCapacityApplyConfiguration{}
+}
+
+// WithQuantity sets the Quantity field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Quantity field is set to the value of the last call.
+func (b *DeviceCapacityApplyConfiguration) WithQuantity(value resource.Quantity) *DeviceCapacityApplyConfiguration {
+	b.Quantity = &value
+	return b
+}

staging/src/k8s.io/client-go/applyconfigurations/utils.go

@@ -1652,6 +1652,8 @@ func ForKind(kind schema.GroupVersionKind) interface{} {
 		return &applyconfigurationsresourcev1beta1.DeviceAllocationResultApplyConfiguration{}
 	case resourcev1beta1.SchemeGroupVersion.WithKind("DeviceAttribute"):
 		return &applyconfigurationsresourcev1beta1.DeviceAttributeApplyConfiguration{}
+	case resourcev1beta1.SchemeGroupVersion.WithKind("DeviceCapacity"):
+		return &applyconfigurationsresourcev1beta1.DeviceCapacityApplyConfiguration{}
 	case resourcev1beta1.SchemeGroupVersion.WithKind("DeviceClaim"):
 		return &applyconfigurationsresourcev1beta1.DeviceClaimApplyConfiguration{}
 	case resourcev1beta1.SchemeGroupVersion.WithKind("DeviceClaimConfiguration"):

staging/src/k8s.io/dynamic-resource-allocation/cel/compile_test.go

@@ -31,7 +31,7 @@ var testcases = map[string]struct {
 	expression         string
 	driver             string
 	attributes         map[resourceapi.QualifiedName]resourceapi.DeviceAttribute
-	capacity           map[resourceapi.QualifiedName]resource.Quantity
+	capacity           map[resourceapi.QualifiedName]resourceapi.DeviceCapacity
 	expectCompileError string
 	expectMatchError   string
 	expectMatch        bool
@@ -149,14 +149,14 @@ var testcases = map[string]struct {
 	},
 	"quantity": {
 		expression:  `device.capacity["dra.example.com"].name.isGreaterThan(quantity("1Ki"))`,
-		capacity:    map[resourceapi.QualifiedName]resource.Quantity{"name": resource.MustParse("1Mi")},
+		capacity:    map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{"name": {Quantity: resource.MustParse("1Mi")}},
 		driver:      "dra.example.com",
 		expectMatch: true,
 		expectCost:  6,
 	},
 	"check-positive": {
 		expression:  `"name" in device.capacity["dra.example.com"] && device.capacity["dra.example.com"].name.isGreaterThan(quantity("1Ki"))`,
-		capacity:    map[resourceapi.QualifiedName]resource.Quantity{"name": resource.MustParse("1Mi")},
+		capacity:    map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{"name": {Quantity: resource.MustParse("1Mi")}},
 		driver:      "dra.example.com",
 		expectMatch: true,
 		expectCost:  10,
@@ -185,8 +185,8 @@ device.attributes["dra.example.com"]["version"].isGreaterThan(semver("0.0.1"))
 			"string":  {StringValue: ptr.To("fish")},
 			"version": {VersionValue: ptr.To("1.0.0")},
 		},
-		capacity: map[resourceapi.QualifiedName]resource.Quantity{
+		capacity: map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{
-			"quantity": resource.MustParse("1Mi"),
+			"quantity": {Quantity: resource.MustParse("1Mi")},
 		},
 		driver:      "dra.example.com",
 		expectMatch: true,