package v1

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

// CSIDriver captures information about a Container Storage
// Interface (CSI) volume driver deployed on the cluster.
// Kubernetes attach detach controller uses this object to
// determine whether attach is required. Kubelet uses this object
// to determine whether pod information needs to be passed on
// mount. CSIDriver objects are non-namespaced.
#CSIDriver: {
	// 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": "storage.k8s.io/v1"

	// 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": "CSIDriver"

	// Standard object metadata. metadata.Name indicates the name of
	// the CSI driver that this object refers to; it MUST be the same
	// name returned by the CSI GetPluginName() call for that driver.
	// The driver name must be 63 characters or less, beginning and
	// ending with an alphanumeric character ([a-z0-9A-Z]) with
	// dashes (-), dots (.), and alphanumerics between. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// spec represents the specification of the CSI Driver.
	"spec"!: #CSIDriverSpec
}

// CSIDriverList is a collection of CSIDriver objects.
#CSIDriverList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of CSIDriver
	"items"!: [...#CSIDriver]

	// 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": "CSIDriverList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// CSIDriverSpec is the specification of a CSIDriver.
#CSIDriverSpec: {
	// attachRequired indicates this CSI volume driver requires an
	// attach operation (because it implements the CSI
	// ControllerPublishVolume() method), and that the Kubernetes
	// attach detach controller should call the attach volume
	// interface which checks the volumeattachment status and waits
	// until the volume is attached before proceeding to mounting.
	// The CSI external-attacher coordinates with CSI volume driver
	// and updates the volumeattachment status when the attach
	// operation is complete. If the value is specified to false, the
	// attach operation will be skipped. Otherwise the attach
	// operation will be called.
	//
	// This field is immutable.
	"attachRequired"?: bool

	// fsGroupPolicy defines if the underlying volume supports
	// changing ownership and permission of the volume before being
	// mounted. Refer to the specific FSGroupPolicy values for
	// additional details.
	//
	// This field was immutable in Kubernetes < 1.29 and now is
	// mutable.
	//
	// Defaults to ReadWriteOnceWithFSType, which will examine each
	// volume to determine if Kubernetes should modify ownership and
	// permissions of the volume. With the default policy the defined
	// fsGroup will only be applied if a fstype is defined and the
	// volume's access mode contains ReadWriteOnce.
	"fsGroupPolicy"?: string

	// nodeAllocatableUpdatePeriodSeconds specifies the interval
	// between periodic updates of the CSINode allocatable capacity
	// for this driver. When set, both periodic updates and updates
	// triggered by capacity-related failures are enabled. If not
	// set, no updates occur (neither periodic nor upon detecting
	// capacity-related failures), and the allocatable.count remains
	// static. The minimum allowed value for this field is 10
	// seconds.
	//
	// This is a beta feature and requires the
	// MutableCSINodeAllocatableCount feature gate to be enabled.
	//
	// This field is mutable.
	"nodeAllocatableUpdatePeriodSeconds"?: int64 & int

	// podInfoOnMount indicates this CSI volume driver requires
	// additional pod information (like podName, podUID, etc.) during
	// mount operations, if set to true. If set to false, pod
	// information will not be passed on mount. Default is false.
	//
	// The CSI driver specifies podInfoOnMount as part of driver
	// deployment. If true, Kubelet will pass pod information as
	// VolumeContext in the CSI NodePublishVolume() calls. The CSI
	// driver is responsible for parsing and validating the
	// information passed in as VolumeContext.
	//
	// The following VolumeContext will be passed if podInfoOnMount is
	// set to true. This list might grow, but the prefix will be
	// used. "csi.storage.k8s.io/pod.name": pod.Name
	// "csi.storage.k8s.io/pod.namespace": pod.Namespace
	// "csi.storage.k8s.io/pod.uid": string(pod.UID)
	// "csi.storage.k8s.io/ephemeral": "true" if the volume is an
	// ephemeral inline volume
	// defined by a CSIVolumeSource, otherwise "false"
	//
	// "csi.storage.k8s.io/ephemeral" is a new feature in Kubernetes
	// 1.16. It is only required for drivers which support both the
	// "Persistent" and "Ephemeral" VolumeLifecycleMode. Other
	// drivers can leave pod info disabled and/or ignore this field.
	// As Kubernetes 1.15 doesn't support this field, drivers can
	// only support one mode when deployed on such a cluster and the
	// deployment determines which mode that is, for example via a
	// command line parameter of the driver.
	//
	// This field was immutable in Kubernetes < 1.29 and now is
	// mutable.
	"podInfoOnMount"?: bool

	// requiresRepublish indicates the CSI driver wants
	// `NodePublishVolume` being periodically called to reflect any
	// possible change in the mounted volume. This field defaults to
	// false.
	//
	// Note: After a successful initial NodePublishVolume call,
	// subsequent calls to NodePublishVolume should only update the
	// contents of the volume. New mount points will not be seen by a
	// running container.
	"requiresRepublish"?: bool

	// seLinuxMount specifies if the CSI driver supports "-o context"
	// mount option.
	//
	// When "true", the CSI driver must ensure that all volumes
	// provided by this CSI driver can be mounted separately with
	// different `-o context` options. This is typical for storage
	// backends that provide volumes as filesystems on block devices
	// or as independent shared volumes. Kubernetes will call
	// NodeStage / NodePublish with "-o context=xyz" mount option
	// when mounting a ReadWriteOncePod volume used in Pod that has
	// explicitly set SELinux context. In the future, it may be
	// expanded to other volume AccessModes. In any case, Kubernetes
	// will ensure that the volume is mounted only with a single
	// SELinux context.
	//
	// When "false", Kubernetes won't pass any special SELinux mount
	// options to the driver. This is typical for volumes that
	// represent subdirectories of a bigger shared filesystem.
	//
	// Default is "false".
	"seLinuxMount"?: bool

	// serviceAccountTokenInSecrets is an opt-in for CSI drivers to
	// indicate that service account tokens should be passed via the
	// Secrets field in NodePublishVolumeRequest instead of the
	// VolumeContext field. The CSI specification provides a
	// dedicated Secrets field for sensitive information like tokens,
	// which is the appropriate mechanism for handling credentials.
	// This addresses security concerns where sensitive tokens were
	// being logged as part of volume context.
	//
	// When "true", kubelet will pass the tokens only in the Secrets
	// field with the key "csi.storage.k8s.io/serviceAccount.tokens".
	// The CSI driver must be updated to read tokens from the Secrets
	// field instead of VolumeContext.
	//
	// When "false" or not set, kubelet will pass the tokens in
	// VolumeContext with the key
	// "csi.storage.k8s.io/serviceAccount.tokens" (existing
	// behavior). This maintains backward compatibility with existing
	// CSI drivers.
	//
	// This field can only be set when TokenRequests is configured.
	// The API server will reject CSIDriver specs that set this field
	// without TokenRequests.
	//
	// Default behavior if unset is to pass tokens in the
	// VolumeContext field.
	"serviceAccountTokenInSecrets"?: bool

	// storageCapacity indicates that the CSI volume driver wants pod
	// scheduling to consider the storage capacity that the driver
	// deployment will report by creating CSIStorageCapacity objects
	// with capacity information, if set to true.
	//
	// The check can be enabled immediately when deploying a driver.
	// In that case, provisioning new volumes with late binding will
	// pause until the driver deployment has published some suitable
	// CSIStorageCapacity object.
	//
	// Alternatively, the driver can be deployed with the field unset
	// or false and it can be flipped later when storage capacity
	// information has been published.
	//
	// This field was immutable in Kubernetes <= 1.22 and now is
	// mutable.
	"storageCapacity"?: bool

	// tokenRequests indicates the CSI driver needs pods' service
	// account tokens it is mounting volume for to do necessary
	// authentication. Kubelet will pass the tokens in VolumeContext
	// in the CSI NodePublishVolume calls. The CSI driver should
	// parse and validate the following VolumeContext:
	// "csi.storage.k8s.io/serviceAccount.tokens": {
	// "<audience>": {
	// "token": <token>,
	// "expirationTimestamp": <expiration timestamp in RFC3339>,
	// },
	// ...
	// }
	//
	// Note: Audience in each TokenRequest should be different and at
	// most one token is empty string. To receive a new token after
	// expiry, RequiresRepublish can be used to trigger
	// NodePublishVolume periodically.
	"tokenRequests"?: [...#TokenRequest]

	// volumeLifecycleModes defines what kind of volumes this CSI
	// volume driver supports. The default if the list is empty is
	// "Persistent", which is the usage defined by the CSI
	// specification and implemented in Kubernetes via the usual
	// PV/PVC mechanism.
	//
	// The other mode is "Ephemeral". In this mode, volumes are
	// defined inline inside the pod spec with CSIVolumeSource and
	// their lifecycle is tied to the lifecycle of that pod. A driver
	// has to be aware of this because it is only going to get a
	// NodePublishVolume call for such a volume.
	//
	// For more information about implementing this mode, see
	// https://kubernetes-csi.github.io/docs/ephemeral-local-volumes.html
	// A driver can support one or more of these modes and more modes
	// may be added in the future.
	//
	// This field is beta. This field is immutable.
	"volumeLifecycleModes"?: [...string]
}

// CSINode holds information about all CSI drivers installed on a
// node. CSI drivers do not need to create the CSINode object
// directly. As long as they use the node-driver-registrar
// sidecar container, the kubelet will automatically populate the
// CSINode object for the CSI driver as part of kubelet plugin
// registration. CSINode has the same name as a node. If the
// object is missing, it means either there are no CSI Drivers
// available on the node, or the Kubelet version is low enough
// that it doesn't create this object. CSINode has an
// OwnerReference that points to the corresponding node object.
#CSINode: {
	// 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": "storage.k8s.io/v1"

	// 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": "CSINode"

	// Standard object's metadata. metadata.name must be the
	// Kubernetes node name.
	"metadata"?: v1.#ObjectMeta

	// spec is the specification of CSINode
	"spec"!: #CSINodeSpec
}

// CSINodeDriver holds information about the specification of one
// CSI driver installed on a node
#CSINodeDriver: {
	// allocatable represents the volume resources of a node that are
	// available for scheduling. This field is beta.
	"allocatable"?: #VolumeNodeResources

	// name represents the name of the CSI driver that this object
	// refers to. This MUST be the same name returned by the CSI
	// GetPluginName() call for that driver.
	"name"!: string

	// nodeID of the node from the driver point of view. This field
	// enables Kubernetes to communicate with storage systems that do
	// not share the same nomenclature for nodes. For example,
	// Kubernetes may refer to a given node as "node1", but the
	// storage system may refer to the same node as "nodeA". When
	// Kubernetes issues a command to the storage system to attach a
	// volume to a specific node, it can use this field to refer to
	// the node name using the ID that the storage system will
	// understand, e.g. "nodeA" instead of "node1". This field is
	// required.
	"nodeID"!: string

	// topologyKeys is the list of keys supported by the driver. When
	// a driver is initialized on a cluster, it provides a set of
	// topology keys that it understands (e.g. "company.com/zone",
	// "company.com/region"). When a driver is initialized on a node,
	// it provides the same topology keys along with values. Kubelet
	// will expose these topology keys as labels on its own node
	// object. When Kubernetes does topology aware provisioning, it
	// can use this list to determine which labels it should retrieve
	// from the node object and pass back to the driver. It is
	// possible for different nodes to use different topology keys.
	// This can be empty if driver does not support topology.
	"topologyKeys"?: [...string]
}

// CSINodeList is a collection of CSINode objects.
#CSINodeList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of CSINode
	"items"!: [...#CSINode]

	// 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": "CSINodeList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// CSINodeSpec holds information about the specification of all
// CSI drivers installed on a node
#CSINodeSpec: {
	// drivers is a list of information of all CSI Drivers existing on
	// a node. If all drivers in the list are uninstalled, this can
	// become empty.
	"drivers"!: [...#CSINodeDriver]
}

// CSIStorageCapacity stores the result of one CSI GetCapacity
// call. For a given StorageClass, this describes the available
// capacity in a particular topology segment. This can be used
// when considering where to instantiate new PersistentVolumes.
//
// For example this can express things like: - StorageClass
// "standard" has "1234 GiB" available in
// "topology.kubernetes.io/zone=us-east1" - StorageClass
// "localssd" has "10 GiB" available in
// "kubernetes.io/hostname=knode-abc123"
//
// The following three cases all imply that no capacity is
// available for a certain combination: - no object exists with
// suitable topology and storage class name - such an object
// exists, but the capacity is unset - such an object exists, but
// the capacity is zero
//
// The producer of these objects can decide which approach is more
// suitable.
//
// They are consumed by the kube-scheduler when a CSI driver opts
// into capacity-aware scheduling with
// CSIDriverSpec.StorageCapacity. The scheduler compares the
// MaximumVolumeSize against the requested size of pending
// volumes to filter out unsuitable nodes. If MaximumVolumeSize
// is unset, it falls back to a comparison against the less
// precise Capacity. If that is also unset, the scheduler assumes
// that capacity is insufficient and tries some other node.
#CSIStorageCapacity: {
	// 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": "storage.k8s.io/v1"

	// capacity is the value reported by the CSI driver in its
	// GetCapacityResponse for a GetCapacityRequest with topology and
	// parameters that match the previous fields.
	//
	// The semantic is currently (CSI spec 1.2) defined as: The
	// available capacity, in bytes, of the storage that can be used
	// to provision volumes. If not set, that information is
	// currently unavailable.
	"capacity"?: resource.#Quantity

	// 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": "CSIStorageCapacity"

	// maximumVolumeSize is the value reported by the CSI driver in
	// its GetCapacityResponse for a GetCapacityRequest with topology
	// and parameters that match the previous fields.
	//
	// This is defined since CSI spec 1.4.0 as the largest size that
	// may be used in a
	// CreateVolumeRequest.capacity_range.required_bytes field to
	// create a volume with the same parameters as those in
	// GetCapacityRequest. The corresponding value in the Kubernetes
	// API is ResourceRequirements.Requests in a volume claim.
	"maximumVolumeSize"?: resource.#Quantity

	// Standard object's metadata. The name has no particular meaning.
	// It must be a DNS subdomain (dots allowed, 253 characters). To
	// ensure that there are no conflicts with other CSI drivers on
	// the cluster, the recommendation is to use csisc-<uuid>, a
	// generated name, or a reverse-domain name which ends with the
	// unique CSI driver name.
	//
	// Objects are namespaced.
	//
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// nodeTopology defines which nodes have access to the storage for
	// which capacity was reported. If not set, the storage is not
	// accessible from any node in the cluster. If empty, the storage
	// is accessible from all nodes. This field is immutable.
	"nodeTopology"?: v1.#LabelSelector

	// storageClassName represents the name of the StorageClass that
	// the reported capacity applies to. It must meet the same
	// requirements as the name of a StorageClass object (non-empty,
	// DNS subdomain). If that object no longer exists, the
	// CSIStorageCapacity object is obsolete and should be removed by
	// its creator. This field is immutable.
	"storageClassName"!: string
}

// CSIStorageCapacityList is a collection of CSIStorageCapacity
// objects.
#CSIStorageCapacityList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of CSIStorageCapacity objects.
	"items"!: [...#CSIStorageCapacity]

	// 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": "CSIStorageCapacityList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// StorageClass describes the parameters for a class of storage
// for which PersistentVolumes can be dynamically provisioned.
//
// StorageClasses are non-namespaced; the name of the storage
// class according to etcd is in ObjectMeta.Name.
#StorageClass: {
	// allowVolumeExpansion shows whether the storage class allow
	// volume expand.
	"allowVolumeExpansion"?: bool

	// allowedTopologies restrict the node topologies where volumes
	// can be dynamically provisioned. Each volume plugin defines its
	// own supported topology specifications. An empty
	// TopologySelectorTerm list means there is no topology
	// restriction. This field is only honored by servers that enable
	// the VolumeScheduling feature.
	"allowedTopologies"?: [...v1_9.#TopologySelectorTerm]

	// 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": "storage.k8s.io/v1"

	// 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": "StorageClass"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// mountOptions controls the mountOptions for dynamically
	// provisioned PersistentVolumes of this storage class. e.g.
	// ["ro", "soft"]. Not validated - mount of the PVs will simply
	// fail if one is invalid.
	"mountOptions"?: [...string]

	// parameters holds the parameters for the provisioner that should
	// create volumes of this storage class.
	"parameters"?: {
		[string]: string
	}

	// provisioner indicates the type of the provisioner.
	"provisioner"!: string

	// reclaimPolicy controls the reclaimPolicy for dynamically
	// provisioned PersistentVolumes of this storage class. Defaults
	// to Delete.
	"reclaimPolicy"?: string

	// volumeBindingMode indicates how PersistentVolumeClaims should
	// be provisioned and bound. When unset, VolumeBindingImmediate
	// is used. This field is only honored by servers that enable the
	// VolumeScheduling feature.
	"volumeBindingMode"?: string
}

// StorageClassList is a collection of storage classes.
#StorageClassList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of StorageClasses
	"items"!: [...#StorageClass]

	// 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": "StorageClassList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// TokenRequest contains parameters of a service account token.
#TokenRequest: {
	// audience is the intended audience of the token in
	// "TokenRequestSpec". It will default to the audiences of kube
	// apiserver.
	"audience"!: string

	// expirationSeconds is the duration of validity of the token in
	// "TokenRequestSpec". It has the same default value of
	// "ExpirationSeconds" in "TokenRequestSpec".
	"expirationSeconds"?: int64 & int
}

// VolumeAttachment captures the intent to attach or detach the
// specified volume to/from the specified node.
//
// VolumeAttachment objects are non-namespaced.
#VolumeAttachment: {
	// 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": "storage.k8s.io/v1"

	// 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": "VolumeAttachment"

	// Standard object metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// spec represents specification of the desired attach/detach
	// volume behavior. Populated by the Kubernetes system.
	"spec"!: #VolumeAttachmentSpec

	// status represents status of the VolumeAttachment request.
	// Populated by the entity completing the attach or detach
	// operation, i.e. the external-attacher.
	"status"?: #VolumeAttachmentStatus
}

// VolumeAttachmentList is a collection of VolumeAttachment
// objects.
#VolumeAttachmentList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of VolumeAttachments
	"items"!: [...#VolumeAttachment]

	// 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": "VolumeAttachmentList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// VolumeAttachmentSource represents a volume that should be
// attached. Right now only PersistentVolumes can be attached via
// external attacher, in the future we may allow also inline
// volumes in pods. Exactly one member can be set.
#VolumeAttachmentSource: {
	// inlineVolumeSpec contains all the information necessary to
	// attach a persistent volume defined by a pod's inline
	// VolumeSource. This field is populated only for the
	// CSIMigration feature. It contains translated fields from a
	// pod's inline VolumeSource to a PersistentVolumeSpec. This
	// field is beta-level and is only honored by servers that
	// enabled the CSIMigration feature.
	"inlineVolumeSpec"?: v1_9.#PersistentVolumeSpec

	// persistentVolumeName represents the name of the persistent
	// volume to attach.
	"persistentVolumeName"?: string
}

// VolumeAttachmentSpec is the specification of a VolumeAttachment
// request.
#VolumeAttachmentSpec: {
	// attacher indicates the name of the volume driver that MUST
	// handle this request. This is the name returned by
	// GetPluginName().
	"attacher"!: string

	// nodeName represents the node that the volume should be attached
	// to.
	"nodeName"!: string

	// source represents the volume that should be attached.
	"source"!: #VolumeAttachmentSource
}

// VolumeAttachmentStatus is the status of a VolumeAttachment
// request.
#VolumeAttachmentStatus: {
	// attachError represents the last error encountered during attach
	// operation, if any. This field must only be set by the entity
	// completing the attach operation, i.e. the external-attacher.
	"attachError"?: #VolumeError

	// attached indicates the volume is successfully attached. This
	// field must only be set by the entity completing the attach
	// operation, i.e. the external-attacher.
	"attached"!: bool

	// attachmentMetadata is populated with any information returned
	// by the attach operation, upon successful attach, that must be
	// passed into subsequent WaitForAttach or Mount calls. This
	// field must only be set by the entity completing the attach
	// operation, i.e. the external-attacher.
	"attachmentMetadata"?: {
		[string]: string
	}

	// detachError represents the last error encountered during detach
	// operation, if any. This field must only be set by the entity
	// completing the detach operation, i.e. the external-attacher.
	"detachError"?: #VolumeError
}

// VolumeAttributesClass represents a specification of mutable
// volume attributes defined by the CSI driver. The class can be
// specified during dynamic provisioning of
// PersistentVolumeClaims, and changed in the
// PersistentVolumeClaim spec after provisioning.
#VolumeAttributesClass: {
	// 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": "storage.k8s.io/v1"

	// Name of the CSI driver This field is immutable.
	"driverName"!: string

	// 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": "VolumeAttributesClass"

	// Standard object's metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// parameters hold volume attributes defined by the CSI driver.
	// These values are opaque to the Kubernetes and are passed
	// directly to the CSI driver. The underlying storage provider
	// supports changing these attributes on an existing volume,
	// however the parameters field itself is immutable. To invoke a
	// volume update, a new VolumeAttributesClass should be created
	// with new parameters, and the PersistentVolumeClaim should be
	// updated to reference the new VolumeAttributesClass.
	//
	// This field is required and must contain at least one key/value
	// pair. The keys cannot be empty, and the maximum number of
	// parameters is 512, with a cumulative max size of 256K. If the
	// CSI driver rejects invalid parameters, the target
	// PersistentVolumeClaim will be set to an "Infeasible" state in
	// the modifyVolumeStatus field.
	"parameters"?: {
		[string]: string
	}
}

// VolumeAttributesClassList is a collection of
// VolumeAttributesClass objects.
#VolumeAttributesClassList: {
	// 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": "storage.k8s.io/v1"

	// items is the list of VolumeAttributesClass objects.
	"items"!: [...#VolumeAttributesClass]

	// 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": "VolumeAttributesClassList"

	// Standard list metadata More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ListMeta
}

// VolumeError captures an error encountered during a volume
// operation.
#VolumeError: {
	// errorCode is a numeric gRPC code representing the error
	// encountered during Attach or Detach operations.
	//
	// This is an optional, beta field that requires the
	// MutableCSINodeAllocatableCount feature gate being enabled to
	// be set.
	"errorCode"?: int32 & int

	// message represents the error encountered during Attach or
	// Detach operation. This string may be logged, so it should not
	// contain sensitive information.
	"message"?: string

	// time represents the time the error was encountered.
	"time"?: v1.#Time
}

// VolumeNodeResources is a set of resource limits for scheduling
// of volumes.
#VolumeNodeResources: {
	// count indicates the maximum number of unique volumes managed by
	// the CSI driver that can be used on a node. A volume that is
	// both attached and mounted on a node is considered to be used
	// once, not twice. The same rule applies for a unique volume
	// that is shared among multiple pods on the same node. If this
	// field is not specified, then the supported number of volumes
	// on this node is unbounded.
	"count"?: int32 & int
}