validator := validation.NewRatchetingSchemaValidator(mediumIntSchema, nil, "", strfmt.Default)
	require.True(t, validator.ValidateUpdate(1, 1, validation.WithRatcheting(nil)).IsValid())
	require.False(t, validator.ValidateUpdate(1, 2, validation.WithRatcheting(nil)).IsValid())
}

var objectSchema *spec.Schema = &spec.Schema{
	SchemaProps: spec.SchemaProps{
		Type: spec.StringOrArray{"object"},

		correlatedObject = common.NewCorrelatedObject(uNew.Object, uOld.Object, &model.Structural{Structural: a.structuralSchema})
		options = append(options, validation.WithRatcheting(correlatedObject))
		celOptions = append(celOptions, cel.WithRatcheting(correlatedObject))
	}

	var errs field.ErrorList
	errs = append(errs, a.validator.ValidateUpdate(ctx, uNew, uOld, a.scale, options...)...)

func NewValidationOptions(opts ...ValidationOption) ValidationOptions {
	options := ValidationOptions{}
	for _, opt := range opts {
		opt(&options)
	}
	return options
}

func WithRatcheting(correlation *common.CorrelatedObject) ValidationOption {
	return func(options *ValidationOptions) {
		options.Ratcheting = true
		options.CorrelatedObject = correlation
	}
}

			Schema:               nodeSchema,
		}
	}

	return nil
}

type options struct {
	ratchetingOptions
}

type Option func(*options)

func WithRatcheting(correlation *common.CorrelatedObject) Option {
	return func(o *options) {
		o.currentCorrelation = correlation
	}
}

				budget = celconfig.RuntimeCELCostBudget
			}
			errs, _ := validator.Validate(
				ctx,
				field.NewPath("root"),
				c.schema,
				c.newObj,
				c.oldObj,
				budget,
				WithRatcheting(common.NewCorrelatedObject(c.newObj, c.oldObj, &model.Structural{Structural: c.schema})),
			)

			require.Len(t, errs, len(c.errors), "must have expected number of errors")