}

func (s *Schema) IsXPreserveUnknownFields() bool {
	return isXPreserveUnknownFields(s.Schema)
}

func (s *Schema) XListType() string {
	return getXListType(s.Schema)
}

func (s *Schema) XMapType() string {
	return getXMapType(s.Schema)
}

func (s *Schema) XListMapKeys() []string {
	return getXListMapKeys(s.Schema)
}

func (s *Schema) XValidations() []common.ValidationRule {

	}
	if in.XListType != nil {
		out.VendorExtensible.AddExtension("x-kubernetes-list-type", *in.XListType)
	}
	if in.XMapType != nil {
		out.VendorExtensible.AddExtension("x-kubernetes-map-type", *in.XMapType)
	}
	if len(in.XValidations) != 0 {
		var serializationValidationRules apiextensionsv1.ValidationRules

	//      the default behaviour for all maps.
	// 2) `atomic`: the list is treated as a single entity, like a scalar.
	//      Atomic maps will be entirely replaced when updated.
	// +optional
	XMapType *string
}

// +k8s:deepcopy-gen=true

// ValidationExtensions contains the Kubernetes OpenAPI v3 extensions that are
// used for validation rather than structure.
type ValidationExtensions struct {

	// resources associated with PVC.
	//
	// This is an alpha field and requires enabling RecoverVolumeExpansionFailure feature.
	// +featureGate=RecoverVolumeExpansionFailure
	// +mapType=granular
	// +optional
	AllocatedResourceStatuses map[ResourceName]ClaimResourceStatus
	// currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using.

			return Typ[String]
		}
	}
	return t
}

// maxType returns the "largest" type that encompasses both x and y.
// If x and y are different untyped numeric types, the result is the type of x or y
// that appears later in this list: integer, rune, floating-point, complex.
// Otherwise, if x != y, the result is nil.
func maxType(x, y Type) Type {
	// We only care about untyped types (for now), so == is good enough.

	out.XIntOrString = in.XIntOrString
	out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys))
	out.XListType = (*string)(unsafe.Pointer(in.XListType))
	out.XMapType = (*string)(unsafe.Pointer(in.XMapType))
	out.XValidations = *(*apiextensions.ValidationRules)(unsafe.Pointer(&in.XValidations))
	return nil
}

	out.XIntOrString = in.XIntOrString
	out.XListMapKeys = *(*[]string)(unsafe.Pointer(&in.XListMapKeys))
	out.XListType = (*string)(unsafe.Pointer(in.XListType))
	out.XMapType = (*string)(unsafe.Pointer(in.XMapType))
	out.XValidations = *(*apiextensions.ValidationRules)(unsafe.Pointer(&in.XValidations))
	return nil
}

			return Typ[String]
		}
	}
	return t
}

// maxType returns the "largest" type that encompasses both x and y.
// If x and y are different untyped numeric types, the result is the type of x or y
// that appears later in this list: integer, rune, floating-point, complex.
// Otherwise, if x != y, the result is nil.
func maxType(x, y Type) Type {
	// We only care about untyped types (for now), so == is good enough.

API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaProps,XListType
API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaProps,XMapType
API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaProps,XPreserveUnknownFields

					Type:     "array",
					XMapType: strPtr("granular"),
				},
			},
			expectedErrors: []validationMatch{
				invalid("spec.validation.openAPIV3Schema.type"),
			},
		},
		{
			name: "unset type with map type extension (granular)",
			input: apiextensions.CustomResourceValidation{
				OpenAPIV3Schema: &apiextensions.JSONSchemaProps{
					XMapType: strPtr("granular"),
				},
			},