"schema": IsDict(
                                    {
                                        "title": "Square",
                                        "maxItems": 2,
                                        "minItems": 2,
                                        "type": "array",
                                        "prefixItems": [

    private final LinkedList<String> content;
    private final int maxItems;

    public LimitedDescription(int maxItems) {
        this.maxItems = maxItems;
        this.content = new LinkedList<String>();
    }

    public LimitedDescription append(String line) {
        content.add(0, line);
        if (content.size() > maxItems) {
            content.removeLast();
        }
        return this;
    }

		// each occurrence of the object they are fields of
		return uint64ptr(1)
	case "array":
		if schema.MaxItems != nil {
			maxItems := uint64(zeroIfNegative(*schema.MaxItems))
			return &maxItems
		}
		return unbounded
	default:
		return uint64ptr(1)
	}
}

func zeroIfNegative(v int64) int64 {
	if v < 0 {
		return 0
	}
	return v

		}
	}

	if in.MinLength != nil {
		in, out := &in.MinLength, &out.MinLength
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}
	if in.MaxItems != nil {
		in, out := &in.MaxItems, &out.MaxItems
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}

	if in.MinItems != nil {
		in, out := &in.MinItems, &out.MinItems
		if *in == nil {

			if itemsType == nil {
				return nil
			}
			var maxItems int64
			if s.MaxItems() != nil {
				maxItems = zeroIfNegative(*s.MaxItems())
			} else {
				maxItems = estimateMaxArrayItemsFromMinSize(itemsType.MinSerializedSize)
			}
			return apiservercel.NewListType(itemsType, maxItems)
		}
		return nil
	case "object":

			ValueValidation: &schema.ValueValidation{
				MaxItems: maxItems,
			},
			ValidationExtensions: schema.ValidationExtensions{
				XValidations: apiextensions.ValidationRules{
					{
						Rule: rule,
					},
				},
			},
		}
	}
}

func genArrayOfArraysWithRule(arrayType, rule string) func(maxItems *int64) *schema.Structural {
	return func(maxItems *int64) *schema.Structural {
		return &schema.Structural{

        "maximum": 9.5,
        "exclusiveMaximum": true,
        "minimum": 11.5,
        "exclusiveMinimum": true,
        "maxLength": 13,
        "minLength": 14,
        "pattern": "patternValue",
        "maxItems": 16,
        "minItems": 17,
        "uniqueItems": true,
        "multipleOf": 19.5,
        "enum": [
          "enumValue"
        ],
        "maxProperties": 21,
        "minProperties": 22,

		}
	}

	if in.MinLength != nil {
		in, out := &in.MinLength, &out.MinLength
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}
	if in.MaxItems != nil {
		in, out := &in.MaxItems, &out.MaxItems
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}

	if in.MinItems != nil {
		in, out := &in.MinItems, &out.MinItems
		if *in == nil {

		}
	}

	if in.MinLength != nil {
		in, out := &in.MinLength, &out.MinLength
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}
	if in.MaxItems != nil {
		in, out := &in.MaxItems, &out.MaxItems
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}

	if in.MinItems != nil {
		in, out := &in.MinItems, &out.MinItems

      exclusiveMinimum: true
      externalDocs:
        description: descriptionValue
        url: urlValue
      format: formatValue
      id: idValue
      items:
      - {}
      maxItems: 16
      maxLength: 13
      maxProperties: 21
      maximum: 9.5
      minItems: 17
      minLength: 14
      minProperties: 22
      minimum: 11.5
      multipleOf: 19.5
      nullable: true