ret.MaxLength = v.MaxLength
	ret.MinLength = v.MinLength
	ret.Pattern = v.Pattern
	ret.MaxItems = v.MaxItems
	ret.MinItems = v.MinItems
	ret.UniqueItems = v.UniqueItems
	ret.MultipleOf = v.MultipleOf
	if v.Enum != nil {
		ret.Enum = make([]interface{}, 0, len(v.Enum))
		for i := range v.Enum {
			ret.Enum = append(ret.Enum, v.Enum[i].Object)
		}
	}
	ret.MaxProperties = v.MaxProperties

        "exclusiveMinimum": true,
        "maxLength": 13,
        "minLength": 14,
        "pattern": "patternValue",
        "maxItems": 16,
        "minItems": 17,
        "uniqueItems": true,
        "multipleOf": 19.5,
        "enum": [
          "enumValue"
        ],
        "maxProperties": 21,
        "minProperties": 22,
        "required": [
          "requiredValue"
        ],
        "items": [

		*out = new(int64)
		**out = **in
	}
	if in.MinItems != nil {
		in, out := &in.MinItems, &out.MinItems
		*out = new(int64)
		**out = **in
	}
	if in.MultipleOf != nil {
		in, out := &in.MultipleOf, &out.MultipleOf
		*out = new(float64)
		**out = **in
	}
	if in.Enum != nil {
		in, out := &in.Enum, &out.Enum
		*out = make([]JSON, len(*in))
		for i := range *in {

      items:
      - {}
      maxItems: 16
      maxLength: 13
      maxProperties: 21
      maximum: 9.5
      minItems: 17
      minLength: 14
      minProperties: 22
      minimum: 11.5
      multipleOf: 19.5
      nullable: true
      oneOf:
      - {}
      pattern: patternValue
      patternProperties:
        patternPropertiesKey: {}
      properties:
        propertiesKey: {}
      required:

}

func (s *Schema) Maximum() *float64 {
	return s.Schema.Maximum
}

func (s *Schema) IsExclusiveMaximum() bool {
	return s.Schema.ExclusiveMaximum
}

func (s *Schema) MultipleOf() *float64 {
	return s.Schema.MultipleOf
}

func (s *Schema) UniqueItems() bool {
	return s.Schema.UniqueItems
}

func (s *Schema) MinItems() *int64 {
	return s.Schema.MinItems
}

        maxItems: 16
        maxLength: 13
        maxProperties: 21
        maximum: 9.5
        minItems: 17
        minLength: 14
        minProperties: 22
        minimum: 11.5
        multipleOf: 19.5
        nullable: true
        oneOf:
        - {}
        pattern: patternValue
        patternProperties:
          patternPropertiesKey: {}
        properties:
          propertiesKey: {}

	if s.Structural.ValueValidation == nil {
		return false
	}
	return s.Structural.ValueValidation.ExclusiveMaximum
}

func (s *Structural) MultipleOf() *float64 {
	if s.Structural.ValueValidation == nil {
		return nil
	}
	return s.Structural.ValueValidation.MultipleOf
}

func (s *Structural) MinItems() *int64 {
	if s.Structural.ValueValidation == nil {
		return nil
	}

		MaxLength:        s.MaxLength,
		MinLength:        s.MinLength,
		Pattern:          s.Pattern,
		MaxItems:         s.MaxItems,
		MinItems:         s.MinItems,
		UniqueItems:      s.UniqueItems,
		MultipleOf:       s.MultipleOf,
		MaxProperties:    s.MaxProperties,
		MinProperties:    s.MinProperties,
		Required:         s.Required,
		Not:              not,
	}

	for _, e := range s.Enum {

// Validations contains OpenAPI validation that the CEL library uses.
type Validations interface {
	Pattern() string
	Minimum() *float64
	IsExclusiveMinimum() bool
	Maximum() *float64
	IsExclusiveMaximum() bool
	MultipleOf() *float64
	MinItems() *int64
	MaxItems() *int64
	MinLength() *int64
	MaxLength() *int64
	MinProperties() *int64
	MaxProperties() *int64
	Required() []string
	Enum() []any
	Nullable() bool

            "maxLength": 13,
            "minLength": 14,
            "pattern": "patternValue",
            "maxItems": 16,
            "minItems": 17,
            "uniqueItems": true,
            "multipleOf": 19.5,
            "enum": [
              "enumValue"
            ],
            "maxProperties": 21,
            "minProperties": 22,
            "required": [
              "requiredValue"
            ],