"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;
    }

    static final int FLAGS_FIND_WITH_BACKUP_INTENT = 0x10;

    private int searchAttributes;
    private int tflags;
    private int informationLevel;
    private int searchStorageType = 0;
    private int maxItems;
    private String wildcard;

    // information levels

    static final int SMB_INFO_STANDARD = 1;
    static final int SMB_INFO_QUERY_EA_SIZE = 2;
    static final int SMB_INFO_QUERY_EAS_FROM_LIST = 3;

		// 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

import jcifs.util.Hexdump;


/**
 * 
 */
public class Trans2FindNext2 extends SmbComTransaction {

    private int sid, informationLevel, resumeKey, tflags;
    private String filename;
    private long maxItems;


    /**
     * 
     * @param config
     * @param sid
     * @param resumeKey
     * @param filename
     * @param batchCount
     * @param batchSize
     */

		}
	}

	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