hibernateContext.addMessageParameter("min", min)
                .addMessageParameter("max", max)
                .buildConstraintViolationWithTemplate(message)
                .addConstraintViolation();
        final int length = value.length();
        return length >= min && length <= max;
    }

    private void validateParameters() {
        if (min < 0) {

    return forwardOrder.max(iterator);
  }

  @Override
  public <E extends T> E min(Iterable<E> iterable) {
    return forwardOrder.max(iterable);
  }

  @Override
  public <E extends T> E max(@ParametricNullness E a, @ParametricNullness E b) {
    return forwardOrder.min(a, b);
  }

  @Override
  public <E extends T> E max(

		<Property name="backup.date.suffix" value="_%d{yyyyMMdd}" />
		<Property name="backup.max.history" value="10" />
		<Property name="backup.max.age" value="90" />
		<Property name="backup.audit.max.age" value="360" />
		<Property name="backup.searchlog.max.age" value="90" />
		<Property name="audit.log.pattern" value="%msg%n" />
		<Property name="searchlog.log.pattern" value="%msg%n" />

def update_and_add(
    language: Annotated[str, typer.Option(envvar="LANGUAGE")],
    max: Annotated[int, typer.Option(envvar="MAX")] = 10,
) -> None:
    print(f"Updating outdated translations for {language}")
    update_outdated(language=language, max=max)
    print(f"Adding missing translations for {language}")
    add_missing(language=language, max=max)
    print(f"Done updating and adding for {language}")


@app.command()

 * <p>Consider projects with dependencies: A → B → D, A → C → D
 * <ul>
 * <li>Project D: weight = 1 (no downstream dependencies)</li>
 * <li>Project B: weight = 2 (1 + max(D=1))</li>
 * <li>Project C: weight = 2 (1 + max(D=1))</li>
 * <li>Project A: weight = 3 (1 + max(B=2, C=2))</li>
 * </ul>
 * <p>Build order: A (weight=3), then B and C (weight=2, ordered by project ID), then D (weight=1)

  public static float max(float... array) {
    checkArgument(array.length > 0);
    float max = array[0];
    for (int i = 1; i < array.length; i++) {
      max = Math.max(max, array[i]);
    }
    return max;
  }

  /**
   * Returns the value nearest to {@code value} which is within the closed range {@code [min..max]}.
   *

    @Required
    @Size(max = 1000)
    public String regularName;

    /** The duplicate hostname that should be redirected to the regular name */
    @Required
    @Size(max = 1000)
    public String duplicateHostName;

    /** The sort order for displaying this duplicate host entry */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure

    /** Token (word) to be added to the dictionary */
    @Required
    @Size(max = 1000)
    public String token;

    /** Segmentation information for the token */
    @Required
    @Size(max = 1000)
    public String segmentation;

    /** Reading (pronunciation) of the token in katakana */
    @Required
    @Size(max = 1000)
    public String reading;

    /** Part of speech tag for the token */

  public static double max(double... array) {
    checkArgument(array.length > 0);
    double max = array[0];
    for (int i = 1; i < array.length; i++) {
      max = Math.max(max, array[i]);
    }
    return max;
  }

  /**
   * Returns the value nearest to {@code value} which is within the closed range {@code [min..max]}.
   *

      }
      double max = accumulator.max();
      double maxByAddAllStats = accumulatorByAddAllStats.max();
      if (values.hasAnyNaN()) {
        assertWithMessage("max of %s", values).that(max).isNaN();
        assertWithMessage("max by addAll(Stats) of %s", values).that(maxByAddAllStats).isNaN();
      } else if (values.hasAnyPositiveInfinity()) {
        assertWithMessage("max of %s", values).that(max).isPositiveInfinity();