package v1beta2

import (
	"cue.dev/x/k8s.io/apimachinery/pkg/apis/meta/v1"
	"cue.dev/x/k8s.io/apimachinery/pkg/runtime"
	v1_9 "cue.dev/x/k8s.io/api/core/v1"
	"cue.dev/x/k8s.io/apimachinery/pkg/api/resource"
)

// AllocatedDeviceStatus contains the status of an allocated device, if the
// driver chooses to report it. This may include driver-specific information.
//
// The combination of Driver, Pool, Device, and ShareID must match the
// corresponding key in Status.Allocation.Devices.
#AllocatedDeviceStatus: {
	// Conditions contains the latest observation of the device's state. If the
	// device has been configured according to the class and claim config
	// references, the `Ready` condition should be True.
	//
	// Must not contain more than 8 entries.
	"conditions"?: [...v1.#Condition]

	// Data contains arbitrary driver-specific data.
	//
	// The length of the raw data must be smaller or equal to 10 Ki.
	"data"?: runtime.#RawExtension

	// Device references one device instance via its name in the driver's resource
	// pool. It must be a DNS label.
	"device"!: string

	// Driver specifies the name of the DRA driver whose kubelet plugin should be
	// invoked to process the allocation once the claim is needed on a node.
	//
	// Must be a DNS subdomain and should end with a DNS domain owned by the vendor
	// of the driver. It should use only lower case characters.
	"driver"!: string

	// NetworkData contains network-related information specific to the device.
	"networkData"?: #NetworkDeviceData

	// This name together with the driver name and the device name field identify
	// which device was allocated (`<driver name>/<pool name>/<device name>`).
	//
	// Must not be longer than 253 characters and may contain one or more DNS
	// sub-domains separated by slashes.
	"pool"!: string

	// ShareID uniquely identifies an individual allocation share of the device.
	"shareID"?: string
}

// AllocationResult contains attributes of an allocated resource.
#AllocationResult: {
	// AllocationTimestamp stores the time when the resources were allocated. This
	// field is not guaranteed to be set, in which case that time is unknown.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gate.
	"allocationTimestamp"?: v1.#Time

	// Devices is the result of allocating devices.
	"devices"?: #DeviceAllocationResult

	// NodeSelector defines where the allocated resources are available. If unset,
	// they are available everywhere.
	"nodeSelector"?: v1_9.#NodeSelector
}

// CELDeviceSelector contains a CEL expression for selecting a device.
#CELDeviceSelector: {
	// Expression is a CEL expression which evaluates a single device. It must
	// evaluate to true when the device under consideration satisfies the desired
	// criteria, and false when it does not. Any other result is an error and
	// causes allocation of devices to abort.
	//
	// The expression's input is an object named "device", which carries the following properties:
	// - driver (string): the name of the driver which defines this device.
	// - attributes (map[string]object): the device's attributes, grouped by prefix
	// (e.g. device.attributes["dra.example.com"] evaluates to an object with all
	// of the attributes which were prefixed by "dra.example.com".
	// - capacity (map[string]object): the device's capacities, grouped by prefix.
	// - allowMultipleAllocations (bool): the allowMultipleAllocations property of the device
	// (v1.34+ with the DRAConsumableCapacity feature enabled).
	//
	// Example: Consider a device with driver="dra.example.com", which exposes two
	// attributes named "model" and "ext.example.com/family" and which exposes one
	// capacity named "modules". This input to this expression would have the
	// following fields:
	//
	// device.driver
	// device.attributes["dra.example.com"].model
	// device.attributes["ext.example.com"].family
	// device.capacity["dra.example.com"].modules
	//
	// The device.driver field can be used to check for a specific driver, either as
	// a high-level precondition (i.e. you only want to consider devices from this
	// driver) or as part of a multi-clause expression that is meant to consider
	// devices from different drivers.
	//
	// The value type of each attribute is defined by the device definition, and
	// users who write these expressions must consult the documentation for their
	// specific drivers. The value type of each capacity is Quantity.
	//
	// If an unknown prefix is used as a lookup in either device.attributes or
	// device.capacity, an empty map will be returned. Any reference to an unknown
	// field will cause an evaluation error and allocation to abort.
	//
	// A robust expression should check for the existence of attributes before referencing them.
	//
	// For ease of use, the cel.bind() function is enabled, and can be used to
	// simplify expressions that access multiple attributes with the same domain.
	// For example:
	//
	// cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
	//
	// When the DRAListTypeAttributes feature gate is enabled, the includes() helper
	// is available and it can work for both scalar and list-type attributes. It
	// was introduced to support smooth migration from scalar attributes to
	// list-type attributes while keeping CEL expressions simple. For example:
	//
	// device.attributes["dra.example.com"].models.includes("some-model")
	//
	// The length of the expression must be smaller or equal to 10 Ki. The cost of
	// evaluating it is also limited based on the estimated number of logical
	// steps.
	"expression"!: string
}

// CapacityRequestPolicy defines how requests consume device capacity.
//
// Must not set more than one ValidRequestValues.
#CapacityRequestPolicy: {
	// Default specifies how much of this capacity is consumed by a request that
	// does not contain an entry for it in DeviceRequest's Capacity.
	"default"?: resource.#Quantity

	// ValidRange defines an acceptable quantity value range in consuming requests.
	//
	// If this field is set, Default must be defined and it must fall within the defined ValidRange.
	//
	// If the requested amount does not fall within the defined range, the request
	// violates the policy, and this device cannot be allocated.
	//
	// If the request doesn't contain this capacity entry, Default value is used.
	"validRange"?: #CapacityRequestPolicyRange

	// ValidValues defines a set of acceptable quantity values in consuming requests.
	//
	// Must not contain more than 10 entries. Must be sorted in ascending order.
	//
	// If this field is set, Default must be defined and it must be included in ValidValues list.
	//
	// If the requested amount does not match any valid value but smaller than some
	// valid values, the scheduler calculates the smallest valid value that is
	// greater than or equal to the request. That is: min(ceil(requestedValue) ∈
	// validValues), where requestedValue ≤ max(validValues).
	//
	// If the requested amount exceeds all valid values, the request violates the
	// policy, and this device cannot be allocated.
	"validValues"?: [...resource.#Quantity]
}

// CapacityRequestPolicyRange defines a valid range for consumable capacity values.
//
// - If the requested amount is less than Min, it is rounded up to the Min value.
// - If Step is set and the requested amount is between Min and Max but not aligned with Step,
// it will be rounded up to the next value equal to Min + (n * Step).
// - If Step is not set, the requested amount is used as-is if it falls within
// the range Min to Max (if set).
// - If the requested or rounded amount exceeds Max (if set), the request does
// not satisfy the policy,
// and the device cannot be allocated.
#CapacityRequestPolicyRange: {
	// Max defines the upper limit for capacity that can be requested.
	//
	// Max must be less than or equal to the capacity value. Min and
	// requestPolicy.default must be less than or equal to the maximum.
	"max"?: resource.#Quantity

	// Min specifies the minimum capacity allowed for a consumption request.
	//
	// Min must be greater than or equal to zero, and less than or equal to the
	// capacity value. requestPolicy.default must be more than or equal to the
	// minimum.
	"min"!: resource.#Quantity

	// Step defines the step size between valid capacity amounts within the range.
	//
	// Max (if set) and requestPolicy.default must be a multiple of Step. Min + Step
	// must be less than or equal to the capacity value.
	"step"?: resource.#Quantity
}

// CapacityRequirements defines the capacity requirements for a specific device request.
#CapacityRequirements: {
	// Requests represent individual device resource requests for distinct
	// resources, all of which must be provided by the device.
	//
	// This value is used as an additional filtering condition against the available
	// capacity on the device. This is semantically equivalent to a CEL selector
	// with `device.capacity[<domain>].<name>.compareTo(quantity(<request
	// quantity>)) >= 0`. For example,
	// device.capacity['test-driver.cdi.k8s.io'].counters.compareTo(quantity('2'))
	// >= 0.
	//
	// When a requestPolicy is defined, the requested amount is adjusted upward to
	// the nearest valid value based on the policy. If the requested amount cannot
	// be adjusted to a valid value—because it exceeds what the requestPolicy
	// allows— the device is considered ineligible for allocation.
	//
	// For any capacity that is not explicitly requested: - If no requestPolicy is
	// set, the default consumed capacity is equal to the full device capacity
	// (i.e., the whole device is claimed).
	// - If a requestPolicy is set, the default consumed capacity is determined
	// according to that policy.
	//
	// If the device allows multiple allocation, the aggregated amount across all
	// requests must not exceed the capacity value. The consumed capacity, which
	// may be adjusted based on the requestPolicy if defined, is recorded in the
	// resource claim’s status.devices[*].consumedCapacity field.
	"requests"?: [string]: resource.#Quantity
}

// Counter describes a quantity associated with a device.
#Counter: {
	// Value defines how much of a certain device counter is available.
	"value"!: resource.#Quantity
}

// CounterSet defines a named set of counters that are available to be used by
// devices defined in the ResourcePool.
//
// The counters are not allocatable by themselves, but can be referenced by
// devices. When a device is allocated, the portion of counters it uses will no
// longer be available for use by other devices.
#CounterSet: {
	// Counters defines the set of counters for this CounterSet The name of each
	// counter must be unique in that set and must be a DNS label.
	//
	// The maximum number of counters is 32.
	"counters"!: [string]: #Counter

	// Name defines the name of the counter set. It must be a DNS label.
	"name"!: string
}

// Device represents one individual hardware instance that can be selected based
// on its attributes. Besides the name, exactly one field must be set.
#Device: {
	// AllNodes indicates that all nodes have access to the device.
	//
	// Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one
	// of NodeName, NodeSelector and AllNodes can be set.
	"allNodes"?: bool

	// AllowMultipleAllocations marks whether the device is allowed to be allocated
	// to multiple DeviceRequests.
	//
	// If AllowMultipleAllocations is set to true, the device can be allocated more
	// than once, and all of its capacity is consumable, regardless of whether the
	// requestPolicy is defined or not.
	"allowMultipleAllocations"?: bool

	// Attributes defines the set of attributes for this device. The name of each
	// attribute must be unique in that set.
	//
	// The maximum number of attributes and capacities combined is 32.
	"attributes"?: [string]: #DeviceAttribute

	// BindingConditions defines the conditions for proceeding with binding. All of
	// these conditions must be set in the per-device status conditions with a
	// value of True to proceed with binding the pod to the node while scheduling
	// the pod.
	//
	// The maximum number of binding conditions is 4.
	//
	// The conditions must be a valid condition type string.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gates.
	"bindingConditions"?: [...string]

	// BindingFailureConditions defines the conditions for binding failure. They may
	// be set in the per-device status conditions. If any is set to "True", a
	// binding failure occurred.
	//
	// The maximum number of binding failure conditions is 4.
	//
	// The conditions must be a valid condition type string.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gates.
	"bindingFailureConditions"?: [...string]

	// BindsToNode indicates if the usage of an allocation involving this device has
	// to be limited to exactly the node that was chosen when allocating the claim.
	// If set to true, the scheduler will set the
	// ResourceClaim.Status.Allocation.NodeSelector to match the node where the
	// allocation was made.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gates.
	"bindsToNode"?: bool

	// Capacity defines the set of capacities for this device. The name of each
	// capacity must be unique in that set.
	//
	// The maximum number of attributes and capacities combined is 32.
	"capacity"?: [string]: #DeviceCapacity

	// ConsumesCounters defines a list of references to sharedCounters and the set
	// of counters that the device will consume from those counter sets.
	//
	// There can only be a single entry per counterSet.
	//
	// The maximum number of device counter consumptions per device is 2.
	"consumesCounters"?: [...#DeviceCounterConsumption]

	// Name is unique identifier among all devices managed by the driver in the
	// pool. It must be a DNS label.
	"name"!: string

	// NodeAllocatableResourceMappings defines the mapping of node resources that
	// are managed by the DRA driver exposing this device. This includes resources
	// currently reported in v1.Node `status.allocatable` that are not extended
	// resources (see
	// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#extended-resources).
	// Examples include "cpu", "memory", "ephemeral-storage", and hugepages. In
	// addition to standard requests made through the Pod `spec`, these resources
	// can also be requested through claims and allocated by the DRA driver. For
	// example, a CPU DRA driver might allocate exclusive CPUs or auxiliary node
	// memory dependencies of an accelerator device. The keys of this map are the
	// node-allocatable resource names (e.g., "cpu", "memory"). Extended resource
	// names are not permitted as keys.
	"nodeAllocatableResourceMappings"?: [string]: #NodeAllocatableResourceMapping

	// NodeName identifies the node where the device is available.
	//
	// Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one
	// of NodeName, NodeSelector and AllNodes can be set.
	"nodeName"?: string

	// NodeSelector defines the nodes where the device is available.
	//
	// Must use exactly one term.
	//
	// Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one
	// of NodeName, NodeSelector and AllNodes can be set.
	"nodeSelector"?: v1_9.#NodeSelector

	// If specified, these are the driver-defined taints.
	//
	// The maximum number of taints is 16. If taints are set for any device in a
	// ResourceSlice, then the maximum number of allowed devices per ResourceSlice
	// is 64 instead of 128.
	//
	// This is a beta field and requires enabling the DRADeviceTaints feature gate.
	"taints"?: [...#DeviceTaint]
}

// DeviceAllocationConfiguration gets embedded in an AllocationResult.
#DeviceAllocationConfiguration: {
	// Opaque provides driver-specific configuration parameters.
	"opaque"?: #OpaqueDeviceConfiguration

	// Requests lists the names of requests where the configuration applies. If
	// empty, its applies to all requests.
	//
	// References to subrequests must include the name of the main request and may
	// include the subrequest using the format <main request>[/<subrequest>]. If
	// just the main request is given, the configuration applies to all
	// subrequests.
	"requests"?: [...string]

	// Source records whether the configuration comes from a class and thus is not
	// something that a normal user would have been able to set or from a claim.
	"source"!: string
}

// DeviceAllocationResult is the result of allocating devices.
#DeviceAllocationResult: {
	// This field is a combination of all the claim and class configuration
	// parameters. Drivers can distinguish between those based on a flag.
	//
	// This includes configuration parameters for drivers which have no allocated
	// devices in the result because it is up to the drivers which configuration
	// parameters they support. They can silently ignore unknown configuration
	// parameters.
	"config"?: [...#DeviceAllocationConfiguration]

	// Results lists all allocated devices.
	"results"?: [...#DeviceRequestAllocationResult]
}

// DeviceAttribute must have exactly one field set.
#DeviceAttribute: {
	// BoolValue is a true/false value.
	"bool"?: bool

	// BoolValues is a non-empty list of true/false values.
	"bools"?: [...bool]

	// IntValue is a number.
	"int"?: int64 & int

	// IntValues is a non-empty list of numbers.
	//
	// This is an alpha field and requires enabling the DRAListTypeAttributes feature gate.
	"ints"?: [...int64 & int]

	// StringValue is a string. Must not be longer than 64 characters.
	"string"?: string

	// StringValues is a non-empty list of strings. Each string must not be longer than 64 characters.
	//
	// This is an alpha field and requires enabling the DRAListTypeAttributes feature gate.
	"strings"?: [...string]

	// VersionValue is a semantic version according to semver.org spec 2.0.0. Must
	// not be longer than 64 characters.
	"version"?: string

	// VersionValues is a non-empty list of semantic versions according to
	// semver.org spec 2.0.0. Each version string must not be longer than 64
	// characters.
	//
	// This is an alpha field and requires enabling the DRAListTypeAttributes feature gate.
	"versions"?: [...string]
}

// DeviceCapacity describes a quantity associated with a device.
#DeviceCapacity: {
	// RequestPolicy defines how this DeviceCapacity must be consumed when the
	// device is allowed to be shared by multiple allocations.
	//
	// The Device must have allowMultipleAllocations set to true in order to set a requestPolicy.
	//
	// If unset, capacity requests are unconstrained: requests can consume any
	// amount of capacity, as long as the total consumed across all allocations
	// does not exceed the device's defined capacity. If request is also unset,
	// default is the full capacity value.
	"requestPolicy"?: #CapacityRequestPolicy

	// Value defines how much of a certain capacity that device has.
	//
	// This field reflects the fixed total capacity and does not change. The
	// consumed amount is tracked separately by scheduler and does not affect this
	// value.
	"value"!: resource.#Quantity
}

// DeviceClaim defines how to request devices with a ResourceClaim.
#DeviceClaim: {
	// This field holds configuration for multiple potential drivers which could
	// satisfy requests in this claim. It is ignored while allocating the claim.
	"config"?: [...#DeviceClaimConfiguration]

	// These constraints must be satisfied by the set of devices that get allocated for the claim.
	"constraints"?: [...#DeviceConstraint]

	// Requests represent individual requests for distinct devices which must all be
	// satisfied. If empty, nothing needs to be allocated.
	"requests"?: [...#DeviceRequest]
}

// DeviceClaimConfiguration is used for configuration parameters in DeviceClaim.
#DeviceClaimConfiguration: {
	// Opaque provides driver-specific configuration parameters.
	"opaque"?: #OpaqueDeviceConfiguration

	// Requests lists the names of requests where the configuration applies. If
	// empty, it applies to all requests.
	//
	// References to subrequests must include the name of the main request and may
	// include the subrequest using the format <main request>[/<subrequest>]. If
	// just the main request is given, the configuration applies to all
	// subrequests.
	"requests"?: [...string]
}

// DeviceClass is a vendor- or admin-provided resource that contains device
// configuration and selectors. It can be referenced in the device requests of
// a claim to apply these presets. Cluster scoped.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
#DeviceClass: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DeviceClass"

	// Standard object metadata
	"metadata"?: v1.#ObjectMeta

	// Spec defines what can be allocated and how to configure it.
	//
	// This is mutable. Consumers have to be prepared for classes changing at any
	// time, either because they get updated or replaced. Claim allocations are
	// done once based on whatever was set in classes at the time of allocation.
	//
	// Changing the spec automatically increments the metadata.generation number.
	"spec"!: #DeviceClassSpec
}

// DeviceClassConfiguration is used in DeviceClass.
#DeviceClassConfiguration: {
	// Opaque provides driver-specific configuration parameters.
	"opaque"?: #OpaqueDeviceConfiguration
}

// DeviceClassList is a collection of classes.
#DeviceClassList: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Items is the list of resource classes.
	"items"!: [...#DeviceClass]

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DeviceClassList"

	// Standard list metadata
	"metadata"?: v1.#ListMeta
}

// DeviceClassSpec is used in a [DeviceClass] to define what can be allocated
// and how to configure it.
#DeviceClassSpec: {
	// Config defines configuration parameters that apply to each device that is
	// claimed via this class. Some classses may potentially be satisfied by
	// multiple drivers, so each instance of a vendor configuration applies to
	// exactly one driver.
	//
	// They are passed to the driver, but are not considered while allocating the claim.
	"config"?: [...#DeviceClassConfiguration]

	// ExtendedResourceName is the extended resource name for the devices of this
	// class. The devices of this class can be used to satisfy a pod's extended
	// resource requests. It has the same format as the name of a pod's extended
	// resource. It should be unique among all the device classes in a cluster. If
	// two device classes have the same name, then the class created later is
	// picked to satisfy a pod's extended resource requests. If two classes are
	// created at the same time, then the name of the class lexicographically
	// sorted first is picked.
	//
	// This is a beta field.
	"extendedResourceName"?: string

	// Each selector must be satisfied by a device which is claimed via this class.
	"selectors"?: [...#DeviceSelector]
}

// DeviceConstraint must have exactly one field set besides Requests.
#DeviceConstraint: {
	// DistinctAttribute requires that all devices in question have this attribute
	// and that its type and value are unique across those devices.
	//
	// When the DRAListTypeAttributes feature gate is enabled, comparison uses set
	// semantics (i.e., element order and duplicates are ignored): list-valued
	// attributes must be pairwise disjoint across devices. Scalar values are
	// treated as singleton sets for backward compatibility.
	//
	// This acts as the inverse of MatchAttribute.
	//
	// This constraint is used to avoid allocating multiple requests to the same
	// device by ensuring attribute-level differentiation.
	//
	// This is useful for scenarios where resource requests must be fulfilled by
	// separate physical devices. For example, a container requests two network
	// interfaces that must be allocated from two different physical NICs.
	"distinctAttribute"?: string

	// MatchAttribute requires that all devices in question have this attribute and
	// that its type and value are the same across those devices.
	//
	// For example, if you specified "dra.example.com/numa" (a hypothetical
	// example!), then only devices in the same NUMA node will be chosen. A device
	// which does not have that attribute will not be chosen. All devices should
	// use a value of the same type for this attribute because that is part of its
	// specification, but if one device doesn't, then it also will not be chosen.
	//
	// When the DRAListTypeAttributes feature gate is enabled, comparison uses set
	// semantics(i.e., element order and duplicates are ignored): list-valued
	// attributes match when the intersection across all devices is non-empty.
	// Scalar values are treated as singleton sets for backward compatibility.
	//
	// Must include the domain qualifier.
	"matchAttribute"?: string

	// Requests is a list of the one or more requests in this claim which must
	// co-satisfy this constraint. If a request is fulfilled by multiple devices,
	// then all of the devices must satisfy the constraint. If this is not
	// specified, this constraint applies to all requests in this claim.
	//
	// References to subrequests must include the name of the main request and may
	// include the subrequest using the format <main request>[/<subrequest>]. If
	// just the main request is given, the constraint applies to all subrequests.
	"requests"?: [...string]
}

// DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
#DeviceCounterConsumption: {
	// CounterSet is the name of the set from which the counters defined will be consumed.
	"counterSet"!: string

	// Counters defines the counters that will be consumed by the device.
	//
	// The maximum number of counters is 32.
	"counters"!: [string]: #Counter
}

// DeviceRequest is a request for devices required for a claim. This is
// typically a request for a single resource like a device, but can also ask
// for several identical devices. With FirstAvailable it is also possible to
// provide a prioritized list of requests.
#DeviceRequest: {
	// Exactly specifies the details for a single request that must be met exactly
	// for the request to be satisfied.
	//
	// One of Exactly or FirstAvailable must be set.
	"exactly"?: #ExactDeviceRequest

	// FirstAvailable contains subrequests, of which exactly one will be selected by
	// the scheduler. It tries to satisfy them in the order in which they are
	// listed here. So if there are two entries in the list, the scheduler will
	// only check the second one if it determines that the first one can not be
	// used.
	//
	// DRA does not yet implement scoring, so the scheduler will select the first
	// set of devices that satisfies all the requests in the claim. And if the
	// requirements can be satisfied on more than one node, other scheduling
	// features will determine which node is chosen. This means that the set of
	// devices allocated to a claim might not be the optimal set available to the
	// cluster. Scoring will be implemented later.
	"firstAvailable"?: [...#DeviceSubRequest]

	// Name can be used to reference this request in a
	// pod.spec.containers[].resources.claims entry and in a constraint of the
	// claim.
	//
	// References using the name in the DeviceRequest will uniquely identify a
	// request when the Exactly field is set. When the FirstAvailable field is set,
	// a reference to the name of the DeviceRequest will match whatever subrequest
	// is chosen by the scheduler.
	//
	// Must be a DNS label.
	"name"!: string
}

// DeviceRequestAllocationResult contains the allocation result for one request.
#DeviceRequestAllocationResult: {
	// AdminAccess indicates that this device was allocated for administrative
	// access. See the corresponding request field for a definition of mode.
	//
	// This is an alpha field and requires enabling the DRAAdminAccess feature gate.
	// Admin access is disabled if this field is unset or set to false, otherwise
	// it is enabled.
	"adminAccess"?: bool

	// BindingConditions contains a copy of the BindingConditions from the
	// corresponding ResourceSlice at the time of allocation.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gates.
	"bindingConditions"?: [...string]

	// BindingFailureConditions contains a copy of the BindingFailureConditions from
	// the corresponding ResourceSlice at the time of allocation.
	//
	// This is a beta field and requires enabling the DRADeviceBindingConditions and
	// DRAResourceClaimDeviceStatus feature gates.
	"bindingFailureConditions"?: [...string]

	// ConsumedCapacity tracks the amount of capacity consumed per device as part of
	// the claim request. The consumed amount may differ from the requested amount:
	// it is rounded up to the nearest valid value based on the device’s
	// requestPolicy if applicable (i.e., may not be less than the requested
	// amount).
	//
	// The total consumed capacity for each device must not exceed the DeviceCapacity's Value.
	//
	// This field is populated only for devices that allow multiple allocations. All
	// capacity entries are included, even if the consumed amount is zero.
	"consumedCapacity"?: [string]: resource.#Quantity

	// Device references one device instance via its name in the driver's resource
	// pool. It must be a DNS label.
	"device"!: string

	// Driver specifies the name of the DRA driver whose kubelet plugin should be
	// invoked to process the allocation once the claim is needed on a node.
	//
	// Must be a DNS subdomain and should end with a DNS domain owned by the vendor
	// of the driver. It should use only lower case characters.
	"driver"!: string

	// This name together with the driver name and the device name field identify
	// which device was allocated (`<driver name>/<pool name>/<device name>`).
	//
	// Must not be longer than 253 characters and may contain one or more DNS
	// sub-domains separated by slashes.
	"pool"!: string

	// Request is the name of the request in the claim which caused this device to
	// be allocated. If it references a subrequest in the firstAvailable list on a
	// DeviceRequest, this field must include both the name of the main request and
	// the subrequest using the format <main request>/<subrequest>.
	//
	// Multiple devices may have been allocated per request.
	"request"!: string

	// ShareID uniquely identifies an individual allocation share of the device,
	// used when the device supports multiple simultaneous allocations. It serves
	// as an additional map key to differentiate concurrent shares of the same
	// device.
	"shareID"?: string

	// A copy of all tolerations specified in the request at the time when the device got allocated.
	//
	// The maximum number of tolerations is 16.
	//
	// This is a beta field and requires enabling the DRADeviceTaints feature gate.
	"tolerations"?: [...#DeviceToleration]
}

// DeviceSelector must have exactly one field set.
#DeviceSelector: {
	// CEL contains a CEL expression for selecting a device.
	"cel"?: #CELDeviceSelector
}

// DeviceSubRequest describes a request for device provided in the
// claim.spec.devices.requests[].firstAvailable array. Each is typically a
// request for a single resource like a device, but can also ask for several
// identical devices.
//
// DeviceSubRequest is similar to ExactDeviceRequest, but doesn't expose the
// AdminAccess field as that one is only supported when requesting a specific
// device.
#DeviceSubRequest: {
	// AllocationMode and its related fields define how devices are allocated to
	// satisfy this subrequest. Supported values are:
	//
	// - ExactCount: This request is for a specific number of devices.
	// This is the default. The exact number is provided in the
	// count field.
	//
	// - All: This subrequest is for all of the matching devices in a pool.
	// Allocation will fail if some devices are already allocated,
	// unless adminAccess is requested.
	//
	// If AllocationMode is not specified, the default mode is ExactCount. If the
	// mode is ExactCount and count is not specified, the default count is one. Any
	// other subrequests must specify this field.
	//
	// More modes may get added in the future. Clients must refuse to handle
	// requests with unknown modes.
	"allocationMode"?: string

	// Capacity define resource requirements against each capacity.
	//
	// If this field is unset and the device supports multiple allocations, the
	// default value will be applied to each capacity according to requestPolicy.
	// For the capacity that has no requestPolicy, default is the full capacity
	// value.
	//
	// Applies to each device allocation. If Count > 1, the request fails if there
	// aren't enough devices that meet the requirements. If AllocationMode is set
	// to All, the request fails if there are devices that otherwise match the
	// request, and have this capacity, with a value >= the requested amount, but
	// which cannot be allocated to this request.
	"capacity"?: #CapacityRequirements

	// Count is used only when the count mode is "ExactCount". Must be greater than
	// zero. If AllocationMode is ExactCount and this field is not specified, the
	// default is one.
	"count"?: int64 & int

	// DeviceClassName references a specific DeviceClass, which can define
	// additional configuration and selectors to be inherited by this subrequest.
	//
	// A class is required. Which classes are available depends on the cluster.
	//
	// Administrators may use this to restrict which devices may get requested by
	// only installing classes with selectors for permitted devices. If users are
	// free to request anything without restrictions, then administrators can
	// create an empty DeviceClass for users to reference.
	"deviceClassName"!: string

	// Name can be used to reference this subrequest in the list of constraints or
	// the list of configurations for the claim. References must use the format
	// <main request>/<subrequest>.
	//
	// Must be a DNS label.
	"name"!: string

	// Selectors define criteria which must be satisfied by a specific device in
	// order for that device to be considered for this subrequest. All selectors
	// must be satisfied for a device to be considered.
	"selectors"?: [...#DeviceSelector]

	// If specified, the request's tolerations.
	//
	// Tolerations for NoSchedule are required to allocate a device which has a
	// taint with that effect. The same applies to NoExecute.
	//
	// In addition, should any of the allocated devices get tainted with NoExecute
	// after allocation and that effect is not tolerated, then all pods consuming
	// the ResourceClaim get deleted to evict them. The scheduler will not let new
	// pods reserve the claim while it has these tainted devices. Once all pods are
	// evicted, the claim will get deallocated.
	//
	// The maximum number of tolerations is 16.
	//
	// This is a beta field and requires enabling the DRADeviceTaints feature gate.
	"tolerations"?: [...#DeviceToleration]
}

// The device this taint is attached to has the "effect" on any claim which does
// not tolerate the taint and, through the claim, to pods using the claim.
#DeviceTaint: {
	// The effect of the taint on claims that do not tolerate the taint and through
	// such claims on the pods using them.
	//
	// Valid effects are None, NoSchedule and NoExecute. PreferNoSchedule as used
	// for nodes is not valid here. More effects may get added in the future.
	// Consumers must treat unknown effects like None.
	"effect"!: string

	// The taint key to be applied to a device. Must be a label name.
	"key"!: string

	// TimeAdded represents the time at which the taint was added or (only in a
	// DeviceTaintRule) the effect was modified. Added automatically during create
	// or update if not set.
	//
	// In addition, in a DeviceTaintRule a value provided during an update gets
	// replaced with the current time if the provided value is the same as the old
	// one and the new effect is different. Changing the key and/or value while
	// keeping the effect unchanged is possible and does not update the time stamp
	// because the eviction which uses it is either already started (NoExecute) or
	// not started yet (NoEffect, NoSchedule).
	"timeAdded"?: v1.#Time

	// The taint value corresponding to the taint key. Must be a label value.
	"value"?: string
}

// DeviceTaintRule adds one taint to all devices which match the selector. This
// has the same effect as if the taint was specified directly in the
// ResourceSlice by the DRA driver.
#DeviceTaintRule: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DeviceTaintRule"

	// Standard object metadata
	"metadata"?: v1.#ObjectMeta

	// Spec specifies the selector and one taint.
	//
	// Changing the spec automatically increments the metadata.generation number.
	"spec"!: #DeviceTaintRuleSpec

	// Status provides information about what was requested in the spec.
	"status"?: #DeviceTaintRuleStatus
}

// DeviceTaintRuleList is a collection of DeviceTaintRules.
#DeviceTaintRuleList: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Items is the list of DeviceTaintRules.
	"items"!: [...#DeviceTaintRule]

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "DeviceTaintRuleList"

	// Standard list metadata
	"metadata"?: v1.#ListMeta
}

// DeviceTaintRuleSpec specifies the selector and one taint.
#DeviceTaintRuleSpec: {
	// DeviceSelector defines which device(s) the taint is applied to. All selector
	// criteria must be satisfied for a device to match. The empty selector matches
	// all devices. Without a selector, no devices are matches.
	"deviceSelector"?: #DeviceTaintSelector

	// The taint that gets applied to matching devices.
	"taint"!: #DeviceTaint
}

// DeviceTaintRuleStatus provides information about an on-going pod eviction.
#DeviceTaintRuleStatus: {
	// Conditions provide information about the state of the DeviceTaintRule and the
	// cluster at some point in time, in a machine-readable and human-readable
	// format.
	//
	// The following condition is currently defined as part of this API, more may
	// get added: - Type: EvictionInProgress - Status: True if there are currently
	// pods which need to be evicted, False otherwise
	// (includes the effects which don't cause eviction).
	// - Reason: not specified, may change - Message: includes information about
	// number of pending pods and already evicted pods
	// in a human-readable format, updated periodically, may change
	//
	// For `effect: None`, the condition above gets set once for each change to the
	// spec, with the message containing information about what would happen if the
	// effect was `NoExecute`. This feedback can be used to decide whether changing
	// the effect to `NoExecute` will work as intended. It only gets set once to
	// avoid having to constantly update the status.
	//
	// Must have 8 or fewer entries.
	"conditions"?: [...v1.#Condition]
}

// DeviceTaintSelector defines which device(s) a DeviceTaintRule applies to. The
// empty selector matches all devices. Without a selector, no devices are
// matched.
#DeviceTaintSelector: {
	// If device is set, only devices with that name are selected. This field
	// corresponds to slice.spec.devices[].name.
	//
	// Setting also driver and pool may be required to avoid ambiguity, but is not required.
	"device"?: string

	// If driver is set, only devices from that driver are selected. This fields
	// corresponds to slice.spec.driver.
	"driver"?: string

	// If pool is set, only devices in that pool are selected.
	//
	// Also setting the driver name may be useful to avoid ambiguity when different
	// drivers use the same pool name, but this is not required because selecting
	// pools from different drivers may also be useful, for example when drivers
	// with node-local devices use the node name as their pool name.
	"pool"?: string
}

// The ResourceClaim this DeviceToleration is attached to tolerates any taint
// that matches the triple <key,value,effect> using the matching operator
// <operator>.
#DeviceToleration: {
	// Effect indicates the taint effect to match. Empty means match all taint
	// effects. When specified, allowed values are NoSchedule and NoExecute.
	"effect"?: string

	// Key is the taint key that the toleration applies to. Empty means match all
	// taint keys. If the key is empty, operator must be Exists; this combination
	// means to match all values and all keys. Must be a label name.
	"key"?: string

	// Operator represents a key's relationship to the value. Valid operators are
	// Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for
	// value, so that a ResourceClaim can tolerate all taints of a particular
	// category.
	"operator"?: string

	// TolerationSeconds represents the period of time the toleration (which must be
	// of effect NoExecute, otherwise this field is ignored) tolerates the taint.
	// By default, it is not set, which means tolerate the taint forever (do not
	// evict). Zero and negative values will be treated as 0 (evict immediately) by
	// the system. If larger than zero, the time when the pod needs to be evicted
	// is calculated as <time when taint was adedd> + <toleration seconds>.
	"tolerationSeconds"?: int64 & int

	// Value is the taint value the toleration matches to. If the operator is
	// Exists, the value must be empty, otherwise just a regular string. Must be a
	// label value.
	"value"?: string
}

// ExactDeviceRequest is a request for one or more identical devices.
#ExactDeviceRequest: {
	// AdminAccess indicates that this is a claim for administrative access to the
	// device(s). Claims with AdminAccess are expected to be used for monitoring or
	// other management services for a device. They ignore all ordinary claims to
	// the device with respect to access modes and any resource allocations.
	//
	// This is an alpha field and requires enabling the DRAAdminAccess feature gate.
	// Admin access is disabled if this field is unset or set to false, otherwise
	// it is enabled.
	"adminAccess"?: bool

	// AllocationMode and its related fields define how devices are allocated to
	// satisfy this request. Supported values are:
	//
	// - ExactCount: This request is for a specific number of devices.
	// This is the default. The exact number is provided in the
	// count field.
	//
	// - All: This request is for all of the matching devices in a pool.
	// At least one device must exist on the node for the allocation to succeed.
	// Allocation will fail if some devices are already allocated,
	// unless adminAccess is requested.
	//
	// If AllocationMode is not specified, the default mode is ExactCount. If the
	// mode is ExactCount and count is not specified, the default count is one. Any
	// other requests must specify this field.
	//
	// More modes may get added in the future. Clients must refuse to handle
	// requests with unknown modes.
	"allocationMode"?: string

	// Capacity define resource requirements against each capacity.
	//
	// If this field is unset and the device supports multiple allocations, the
	// default value will be applied to each capacity according to requestPolicy.
	// For the capacity that has no requestPolicy, default is the full capacity
	// value.
	//
	// Applies to each device allocation. If Count > 1, the request fails if there
	// aren't enough devices that meet the requirements. If AllocationMode is set
	// to All, the request fails if there are devices that otherwise match the
	// request, and have this capacity, with a value >= the requested amount, but
	// which cannot be allocated to this request.
	"capacity"?: #CapacityRequirements

	// Count is used only when the count mode is "ExactCount". Must be greater than
	// zero. If AllocationMode is ExactCount and this field is not specified, the
	// default is one.
	"count"?: int64 & int

	// DeviceClassName references a specific DeviceClass, which can define
	// additional configuration and selectors to be inherited by this request.
	//
	// A DeviceClassName is required.
	//
	// Administrators may use this to restrict which devices may get requested by
	// only installing classes with selectors for permitted devices. If users are
	// free to request anything without restrictions, then administrators can
	// create an empty DeviceClass for users to reference.
	"deviceClassName"!: string

	// Selectors define criteria which must be satisfied by a specific device in
	// order for that device to be considered for this request. All selectors must
	// be satisfied for a device to be considered.
	"selectors"?: [...#DeviceSelector]

	// If specified, the request's tolerations.
	//
	// Tolerations for NoSchedule are required to allocate a device which has a
	// taint with that effect. The same applies to NoExecute.
	//
	// In addition, should any of the allocated devices get tainted with NoExecute
	// after allocation and that effect is not tolerated, then all pods consuming
	// the ResourceClaim get deleted to evict them. The scheduler will not let new
	// pods reserve the claim while it has these tainted devices. Once all pods are
	// evicted, the claim will get deallocated.
	//
	// The maximum number of tolerations is 16.
	//
	// This is a beta field and requires enabling the DRADeviceTaints feature gate.
	"tolerations"?: [...#DeviceToleration]
}

// NetworkDeviceData provides network-related details for the allocated device.
// This information may be filled by drivers or other components to configure
// or identify the device within a network context.
#NetworkDeviceData: {
	// HardwareAddress represents the hardware address (e.g. MAC Address) of the
	// device's network interface.
	//
	// Must not be longer than 128 bytes.
	"hardwareAddress"?: string

	// InterfaceName specifies the name of the network interface associated with the
	// allocated device. This might be the name of a physical or virtual network
	// interface being configured in the pod.
	//
	// Must not be longer than 256 bytes.
	"interfaceName"?: string

	// IPs lists the network addresses assigned to the device's network interface.
	// This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR
	// notation, which includes both the address and the associated subnet mask.
	// e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
	"ips"?: [...string]
}

// NodeAllocatableResourceMapping defines the translation between the DRA
// device/capacity units requested to the corresponding quantity of the node
// allocatable resource.
#NodeAllocatableResourceMapping: {
	// AllocationMultiplier is used as a multiplier for the allocated device count
	// or the allocated capacity in the claim. It defaults to 1 if not specified.
	// How the field is used also depends on whether `capacityKey` is set. 1. If
	// `capacityKey` is NOT set: `allocationMultiplier` multiplies the device count
	// allocated to the claim.
	// a. A DRA driver representing each CPU core as a device would have
	// {ResourceName: "cpu", allocationMultiplier: "2"} in its
	// `nodeAllocatableResourceMappings`. If 4 devices are allocated to the claim,
	// 4 * 2 CPUs would be considered as allocated and subtracted from the node's capacity.
	// b. A GPU device that needs additional node memory per GPU allocation would
	// have {ResourceName: "memory", allocationMultiplier: "2Gi"}. Each allocated
	// GPU device instance of this type will account for 2Gi of memory.
	//
	// 2. If `capacityKey` IS set: `allocationMultiplier` is multiplied by the
	// amount of that capacity consumed.
	// The final node allocatable resource amount is `consumedCapacity[capacityKey]`
	// * `allocationMultiplier`.
	// For example, if a Device's capacity "dra.example.com/cores" is consumed,
	// and each "core" provides 2 "cpu"s, the mapping would be:
	// {ResourceName: "cpu", capacityKey: "dra.example.com/cores", allocationMultiplier: "2"}.
	// If a claim consumes 8 "dra.example.com/cores", the CPU footprint is 8 * 2 = 16.
	"allocationMultiplier"?: resource.#Quantity

	// CapacityKey references a capacity name defined as a key in the
	// `spec.devices[*].capacity` map. When this field is set, the value associated
	// with this key in the `status.allocation.devices.results[*].consumedCapacity`
	// map (for a specific claim allocation) determines the base quantity for the
	// node allocatable resource. If `allocationMultiplier` is also set, it is
	// multiplied with the base quantity. For example, if
	// `spec.devices[*].capacity` has an entry "dra.example.com/memory": "128Gi",
	// and this field is set to "dra.example.com/memory", then for a claim
	// allocation that consumes { "dra.example.com/memory": "4Gi" } the base
	// quantity for the node allocatable resource mapping will be "4Gi", and
	// `allocationMultiplier` should be omitted or set to "1".
	"capacityKey"?: string
}

// OpaqueDeviceConfiguration contains configuration parameters for a driver in a
// format defined by the driver vendor.
#OpaqueDeviceConfiguration: {
	// Driver is used to determine which kubelet plugin needs to be passed these
	// configuration parameters.
	//
	// An admission policy provided by the driver developer could use this to decide
	// whether it needs to validate them.
	//
	// Must be a DNS subdomain and should end with a DNS domain owned by the vendor
	// of the driver. It should use only lower case characters.
	"driver"!: string

	// Parameters can contain arbitrary data. It is the responsibility of the driver
	// developer to handle validation and versioning. Typically this includes
	// self-identification and a version ("kind" + "apiVersion" for Kubernetes
	// types), with conversion between different versions.
	//
	// The length of the raw data must be smaller or equal to 10 Ki.
	"parameters"!: runtime.#RawExtension
}

// ResourceClaim describes a request for access to resources in the cluster, for
// use by workloads. For example, if a workload needs an accelerator device
// with specific properties, this is how that request is expressed. The status
// stanza tracks whether this claim has been satisfied and what specific
// resources have been allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
#ResourceClaim: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceClaim"

	// Standard object metadata
	"metadata"?: v1.#ObjectMeta

	// Spec describes what is being requested and how to configure it. The spec is immutable.
	"spec"!: #ResourceClaimSpec

	// Status describes whether the claim is ready to use and what has been allocated.
	"status"?: #ResourceClaimStatus
}

// ResourceClaimConsumerReference contains enough information to let you locate
// the consumer of a ResourceClaim. The user must be a resource in the same
// namespace as the ResourceClaim.
#ResourceClaimConsumerReference: {
	// APIGroup is the group for the resource being referenced. It is empty for the
	// core API. This matches the group in the APIVersion that is used when
	// creating the resources.
	"apiGroup"?: string

	// Name is the name of resource being referenced.
	"name"!: string

	// Resource is the type of resource being referenced, for example "pods".
	"resource"!: string

	// UID identifies exactly one incarnation of the resource.
	"uid"!: string
}

// ResourceClaimList is a collection of claims.
#ResourceClaimList: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Items is the list of resource claims.
	"items"!: [...#ResourceClaim]

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceClaimList"

	// Standard list metadata
	"metadata"?: v1.#ListMeta
}

// ResourceClaimSpec defines what is being requested in a ResourceClaim and how to configure it.
#ResourceClaimSpec: {
	// Devices defines how to request devices.
	"devices"?: #DeviceClaim
}

// ResourceClaimStatus tracks whether the resource has been allocated and what
// the result of that was.
#ResourceClaimStatus: {
	// Allocation is set once the claim has been allocated successfully.
	"allocation"?: #AllocationResult

	// Devices contains the status of each device allocated for this claim, as
	// reported by the driver. This can include driver-specific information.
	// Entries are owned by their respective drivers.
	"devices"?: [...#AllocatedDeviceStatus]

	// ReservedFor indicates which entities are currently allowed to use the claim.
	// A Pod which references a ResourceClaim which is not reserved for that Pod
	// will not be started. A claim that is in use or might be in use because it
	// has been reserved must not get deallocated.
	//
	// In a cluster with multiple scheduler instances, two pods might get scheduled
	// concurrently by different schedulers. When they reference the same
	// ResourceClaim which already has reached its maximum number of consumers,
	// only one pod can be scheduled.
	//
	// Both schedulers try to add their pod to the claim.status.reservedFor field,
	// but only the update that reaches the API server first gets stored. The other
	// one fails with an error and the scheduler which issued it knows that it must
	// put the pod back into the queue, waiting for the ResourceClaim to become
	// usable again.
	//
	// There can be at most 256 such reservations. This may get increased in the
	// future, but not reduced.
	"reservedFor"?: [...#ResourceClaimConsumerReference]
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
#ResourceClaimTemplate: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceClaimTemplate"

	// Standard object metadata
	"metadata"?: v1.#ObjectMeta

	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the control
	// plane for a Pod when needed and then not get updated anymore.
	"spec"!: #ResourceClaimTemplateSpec
}

// ResourceClaimTemplateList is a collection of claim templates.
#ResourceClaimTemplateList: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Items is the list of resource claim templates.
	"items"!: [...#ResourceClaimTemplate]

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceClaimTemplateList"

	// Standard list metadata
	"metadata"?: v1.#ListMeta
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
#ResourceClaimTemplateSpec: {
	// ObjectMeta may contain labels and annotations that will be copied into the
	// ResourceClaim when creating it. No other fields are allowed and will be
	// rejected during validation.
	"metadata"?: v1.#ObjectMeta

	// Spec for the ResourceClaim. The entire content is copied unchanged into the
	// ResourceClaim that gets created from this template. The same fields as in a
	// ResourceClaim are also valid here.
	"spec"!: #ResourceClaimSpec
}

// ResourcePool describes the pool that ResourceSlices belong to.
#ResourcePool: {
	// Generation tracks the change in a pool over time. Whenever a driver changes
	// something about one or more of the resources in a pool, it must change the
	// generation in all ResourceSlices which are part of that pool. Consumers of
	// ResourceSlices should only consider resources from the pool with the highest
	// generation number. The generation may be reset by drivers, which should be
	// fine for consumers, assuming that all ResourceSlices in a pool are updated
	// to match or deleted.
	//
	// Combined with ResourceSliceCount, this mechanism enables consumers to detect
	// pools which are comprised of multiple ResourceSlices and are in an
	// incomplete state.
	"generation"!: int64 & int

	// Name is used to identify the pool. For node-local devices, this is often the
	// node name, but this is not required.
	//
	// It must not be longer than 253 characters and must consist of one or more DNS
	// sub-domains separated by slashes. This field is immutable.
	"name"!: string

	// ResourceSliceCount is the total number of ResourceSlices in the pool at this
	// generation number. Must be greater than zero.
	//
	// Consumers can use this to check whether they have seen all ResourceSlices
	// belonging to the same pool.
	"resourceSliceCount"!: int64 & int
}

// ResourceSlice represents one or more resources in a pool of similar
// resources, managed by a common driver. A pool may span more than one
// ResourceSlice, and exactly how many ResourceSlices comprise a pool is
// determined by the driver.
//
// At the moment, the only supported resources are devices with attributes and
// capacities. Each device in a given pool, regardless of how many
// ResourceSlices, must have a unique name. The ResourceSlice in which a device
// gets published may change over time. The unique identifier for a device is
// the tuple <driver name>, <pool name>, <device name>.
//
// Whenever a driver needs to update a pool, it increments the
// pool.Spec.Pool.Generation number and updates all ResourceSlices with that
// new number and new resource definitions. A consumer must only use
// ResourceSlices with the highest generation number and ignore all others.
//
// When allocating all resources in a pool matching certain criteria or when
// looking for the best solution among several different alternatives, a
// consumer should check the number of ResourceSlices in a pool (included in
// each ResourceSlice) to determine whether its view of a pool is complete and
// if not, should wait until the driver has completed updating the pool.
//
// For resources that are not local to a node, the node name is not set.
// Instead, the driver may use a node selector to specify where the devices are
// available.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
#ResourceSlice: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceSlice"

	// Standard object metadata
	"metadata"?: v1.#ObjectMeta

	// Contains the information published by the driver.
	//
	// Changing the spec automatically increments the metadata.generation number.
	"spec"!: #ResourceSliceSpec
}

// ResourceSliceList is a collection of ResourceSlices.
#ResourceSliceList: {
	// APIVersion defines the versioned schema of this representation of an object.
	// Servers should convert recognized schemas to the latest internal value, and
	// may reject unrecognized values. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "resource.k8s.io/v1beta2"

	// Items is the list of resource ResourceSlices.
	"items"!: [...#ResourceSlice]

	// Kind is a string value representing the REST resource this object represents.
	// Servers may infer this from the endpoint the client submits requests to.
	// Cannot be updated. In CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "ResourceSliceList"

	// Standard list metadata
	"metadata"?: v1.#ListMeta
}

// ResourceSliceSpec contains the information published by the driver in one ResourceSlice.
#ResourceSliceSpec: {
	// AllNodes indicates that all nodes have access to the resources in the pool.
	//
	// Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
	"allNodes"?: bool

	// Devices lists some or all of the devices in this pool.
	//
	// Must not have more than 128 entries. If any device uses taints or consumes
	// counters the limit is 64.
	//
	// Only one of Devices and SharedCounters can be set in a ResourceSlice.
	"devices"?: [...#Device]

	// Driver identifies the DRA driver providing the capacity information. A field
	// selector can be used to list only ResourceSlice objects with a certain
	// driver name.
	//
	// Must be a DNS subdomain and should end with a DNS domain owned by the vendor
	// of the driver. It should use only lower case characters. This field is
	// immutable.
	"driver"!: string

	// NodeName identifies the node which provides the resources in this pool. A
	// field selector can be used to list only ResourceSlice objects belonging to a
	// certain node.
	//
	// This field can be used to limit access from nodes to ResourceSlices with the
	// same node name. It also indicates to autoscalers that adding new nodes of
	// the same type as some old node might also make new resources available.
	//
	// Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection
	// must be set. This field is immutable.
	"nodeName"?: string

	// NodeSelector defines which nodes have access to the resources in the pool,
	// when that pool is not limited to a single node.
	//
	// Must use exactly one term.
	//
	// Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
	"nodeSelector"?: v1_9.#NodeSelector

	// PerDeviceNodeSelection defines whether the access from nodes to resources in
	// the pool is set on the ResourceSlice level or on each device. If it is set
	// to true, every device defined the ResourceSlice must specify this
	// individually.
	//
	// Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
	"perDeviceNodeSelection"?: bool

	// Pool describes the pool that this ResourceSlice belongs to.
	"pool"!: #ResourcePool

	// SharedCounters defines a list of counter sets, each of which has a name and a
	// list of counters available.
	//
	// The names of the counter sets must be unique in the ResourcePool.
	//
	// Only one of Devices and SharedCounters can be set in a ResourceSlice.
	//
	// The maximum number of counter sets is 8.
	"sharedCounters"?: [...#CounterSet]
}