type StructuralValidationRule struct {
	rule, message, messageExpression, fieldPath string
}

func (s *StructuralValidationRule) Rule() string {
	return s.rule
}
func (s *StructuralValidationRule) Message() string {
	return s.message
}
func (s *StructuralValidationRule) FieldPath() string {
	return s.fieldPath
}
func (s *StructuralValidationRule) MessageExpression() string {
	return s.messageExpression
}

					warning.AddWarning(ctx, "", e.Error())
				} else {
					errs = append(errs, e)
				}
			}

			if compiled.MessageExpression != nil {
				messageExpression, newRemainingBudget, msgErr := evalMessageExpression(ctx, compiled.MessageExpression, rule.MessageExpression, activation, remainingBudget)
				if msgErr != nil {
					if msgErr.Type == cel.ErrorTypeInternal {

	// MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails.
	// Since messageExpression is used as a failure message, it must evaluate to a string.
	// If both message and messageExpression are present on a rule, then messageExpression will be used if validation

	// MessageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails.
	// Since messageExpression is used as a failure message, it must evaluate to a string.
	// If both message and messageExpression are present on a rule, then messageExpression will be used if validation

  optional string reason = 3;

  // messageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails.
  // Since messageExpression is used as a failure message, it must evaluate to a string.
  // If both message and messageExpression are present on a validation, then messageExpression will be used if validation fails.

	MessageExpressionField string `json:"messageExpression"`
	PathField              string `json:"fieldPath"`
}

func (v ValidationRule) Rule() string {
	return v.RuleField
}

func (v ValidationRule) Message() string {
	return v.MessageField
}

func (v ValidationRule) FieldPath() string {
	return v.PathField
}

func (v ValidationRule) MessageExpression() string {
	return v.MessageExpressionField
}

	// messageExpression declares a CEL expression that evaluates to the validation failure message that is returned when this rule fails.
	// Since messageExpression is used as a failure message, it must evaluate to a string.
	// If both message and messageExpression are present on a validation, then messageExpression will be used if validation fails.

	celExpressionAccessor := make([]cel.ExpressionAccessor, len(inputValidations))
	for i, validation := range inputValidations {
		if validation.MessageExpression != "" {
			condition := MessageExpressionCondition{
				MessageExpression: validation.MessageExpression,
			}
			celExpressionAccessor[i] = &condition
		}
	}
	return celExpressionAccessor
}

      x-kubernetes-map-type: x-kubernetes-map-typeValue
      x-kubernetes-preserve-unknown-fields: true
      x-kubernetes-validations:
      - fieldPath: fieldPathValue
        message: messageValue
        messageExpression: messageExpressionValue
        optionalOldSelf: true
        reason: reasonValue
        rule: ruleValue
  version: versionValue
  versions:
  - additionalPrinterColumns:
    - JSONPath: JSONPathValue

			messageExpression:     `"str with \na newline"`,
			costBudget:            celconfig.RuntimeCELCostBudget,
			expectedLogErr:        "messageExpression should not contain line breaks",
			expectedValidationErr: "message not messageExpression",
		},
		{
			name:                  "messageExpression is not allowed to generate messages >5000 characters",
			message:               "message not messageExpression",