func (m *VolumeNodeAffinity) Reset()      { *m = VolumeNodeAffinity{} }
func (*VolumeNodeAffinity) ProtoMessage() {}
func (*VolumeNodeAffinity) Descriptor() ([]byte, []int) {
	return fileDescriptor_6c07b07c062484ab, []int{220}
}
func (m *VolumeNodeAffinity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

  // Defaults to "" (volume's root).
  // SubPathExpr and SubPath are mutually exclusive.
  // +optional
  optional string subPathExpr = 6;
}

// VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
message VolumeNodeAffinity {
  // required specifies hard node constraints that must be met.
  optional NodeSelector required = 1;
}

	// +featureGate=VolumeAttributesClass
	// +optional
	VolumeAttributesClassName *string
}

// VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
type VolumeNodeAffinity struct {
	// Required specifies hard node constraints that must be met.
	Required *NodeSelector
}

	}
	return allErrs
}

// validateVolumeNodeAffinity tests that the PersistentVolume.NodeAffinity has valid data
// returns:
// - true if volumeNodeAffinity is set
// - errorList if there are validation errors
func validateVolumeNodeAffinity(nodeAffinity *core.VolumeNodeAffinity, fldPath *field.Path) (bool, field.ErrorList) {
	allErrs := field.ErrorList{}

	if nodeAffinity == nil {
		return false, allErrs
	}

  // depending on the mount result.
  // +featureGate=RecursiveReadOnlyMounts
  // +optional
  optional string recursiveReadOnly = 4;
}

// VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
message VolumeNodeAffinity {
  // required specifies hard node constraints that must be met.
  optional NodeSelector required = 1;
}

        }
      },
      "required": [
        "name",
        "mountPath"
      ],
      "type": "object"
    },
    "io.k8s.api.core.v1.VolumeNodeAffinity": {
      "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.",
      "properties": {
        "required": {
          "$ref": "#/definitions/io.k8s.api.core.v1.NodeSelector",

	// +optional
	VolumeAttributesClassName *string `json:"volumeAttributesClassName,omitempty" protobuf:"bytes,10,opt,name=volumeAttributesClassName"`
}

// VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
type VolumeNodeAffinity struct {
	// required specifies hard node constraints that must be met.
	Required *NodeSelector `json:"required,omitempty" protobuf:"bytes,1,opt,name=required"`
}

            "x-kubernetes-list-type": "atomic"
          }
        },
        "type": "object",
        "x-kubernetes-map-type": "atomic"
      },
      "io.k8s.api.core.v1.VolumeNodeAffinity": {
        "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.",
        "properties": {
          "required": {
            "allOf": [
              {

	return map_VolumeMountStatus
}

var map_VolumeNodeAffinity = map[string]string{
	"":         "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.",
	"required": "required specifies hard node constraints that must be met.",
}

func (VolumeNodeAffinity) SwaggerDoc() map[string]string {
	return map_VolumeNodeAffinity
}

var map_VolumeProjection = map[string]string{

          }
        },
        "required": [
          "name",
          "mountPath"
        ],
        "type": "object"
      },
      "io.k8s.api.core.v1.VolumeNodeAffinity": {
        "description": "VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.",
        "properties": {
          "required": {
            "allOf": [
              {