"name": {
											Type: "string",
											XValidations: apiextensions.ValidationRules{
												{
													Rule: "self == 'singleton'",
												},
											},
											Default: jsonPtr("singleton"),
										},
									},
								},
							},
						},
						"value": {
							Type: "string",
							XValidations: apiextensions.ValidationRules{
								{

	return s.messageExpression
}

func (s *Structural) XValidations() []common.ValidationRule {
	if len(s.Structural.XValidations) == 0 {
		return nil
	}
	result := make([]common.ValidationRule, len(s.Structural.XValidations))
	for i, v := range s.Structural.XValidations {

	}
}

func (x *ValidationExtensions) toKubeOpenAPI(ret *spec.Schema) {
	if x == nil {
		return
	}

	if len(x.XValidations) > 0 {
		ret.VendorExtensible.AddExtension("x-kubernetes-validations", x.XValidations)
	}
}

func (v *ValueValidation) toKubeOpenAPI(ret *spec.Schema) {
	if v == nil {
		return
	}

	ret.Format = v.Format
	ret.Maximum = v.Maximum

API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaProps,XPreserveUnknownFields
API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaProps,XValidations
API rule violation: names_match,k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1,JSONSchemaPropsOrArray,JSONSchemas

func (in *ValidationExtensions) DeepCopyInto(out *ValidationExtensions) {
	*out = *in
	if in.XValidations != nil {
		in, out := &in.XValidations, &out.XValidations
		*out = make(v1.ValidationRules, len(*in))
		for i := range *in {
			(*in)[i].DeepCopyInto(&(*out)[i])
		}
	}
	return
}

	IsXIntOrString() bool
	IsXEmbeddedResource() bool
	IsXPreserveUnknownFields() bool
	XListType() string
	XListMapKeys() []string
	XMapType() string
	XValidations() []ValidationRule
}

// ValidationRule represents a single x-kubernetes-validations rule.
type ValidationRule interface {
	Rule() string
	Message() string
	MessageExpression() string
	FieldPath() string
}

	if s == nil {
		return nil, nil
	}

	ret := &ValidationExtensions{}
	if err := apiextensionsv1.Convert_apiextensions_ValidationRules_To_v1_ValidationRules(&s.XValidations, &ret.XValidations, nil); err != nil {
		return nil, err
	}

	return ret, nil
}

// validateUnsupportedFields checks that those fields rejected by validation are actually unset.

}

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

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

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

func (s *Schema) WithTypeAndObjectMeta() common.Schema {
	return &Schema{common.WithTypeAndObjectMeta(s.Schema)}
}

// used for validation rather than structure.
type ValidationExtensions struct {
	// x-kubernetes-validations describes a list of validation rules for expression validation.
	// Use the v1 struct since this gets serialized as an extension.
	XValidations apiextensionsv1.ValidationRules
}

// +k8s:deepcopy-gen=true

    ```

## Recap

With `Query`, `Path` (and others you haven't seen yet) you can declare metadata and string validations in the same ways as with [Query Parameters and String Validations](query-params-str-validations.md){.internal-link target=_blank}.

And you can also declare numeric validations:

* `gt`: `g`reater `t`han
* `ge`: `g`reater than or `e`qual
* `lt`: `l`ess `t`han
* `le`: `l`ess than or `e`qual