replaceWith = ReplaceWith(expression = "tlsVersions"),
    level = DeprecationLevel.ERROR,
  )
  fun tlsVersions(): List<TlsVersion>? = tlsVersions

  @JvmName("-deprecated_supportsTlsExtensions")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "supportsTlsExtensions"),
    level = DeprecationLevel.ERROR,
  )
  fun supportsTlsExtensions(): Boolean = supportsTlsExtensions

    }

    /**
     * Updates the dictionary file with content from an input stream.
     *
     * @param in The input stream containing the new dictionary content.
     * @throws IOException if an I/O error occurs.
     */
    public synchronized void update(final InputStream in) throws IOException {
        try (StemmerOverrideUpdater updater = new StemmerOverrideUpdater(null)) {
            reload(updater, in);
        }

El mismo error aparecería si proporcionaras un `float` en lugar de un `int`, como en: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>

/// check | Revisa

Entonces, con la misma declaración de tipo de Python, **FastAPI** te ofrece validación de datos.

Nota que el error también indica claramente el punto exacto donde la validación falló.

    }

    return closeable;
  }

  /**
   * Stores the given throwable and rethrows it. It will be rethrown as is if it is an {@code
   * IOException}, {@code RuntimeException} or {@code Error}. Otherwise, it will be rethrown wrapped
   * in a {@code RuntimeException}. <b>Note:</b> Be sure to declare all of the checked exception
   * types your try block can throw when calling an overload of this method so as to avoid losing

 */
package jcifs.spnego;

import jcifs.CIFSException;

/**
 * Exception thrown during SPNEGO authentication processing.
 *
 * This exception indicates an error in SPNEGO token processing,
 * negotiation, or authentication flow.
 *
 * @author mbechler
 */
public class SpnegoException extends CIFSException {

    /**
     *
     */

     *
     * @param other the other resource locator to compare with
     * @return whether the paths share a common root
     * @throws CIFSException if an error occurs during comparison
     */
    boolean overlaps(SmbResourceLocator other) throws CIFSException;

    /**
     * Internal: for testing only
     *
     * @param dr the DFS referral data to process

            context.terminal.writer().println(secDispatcher.decrypt(encrypted));
            return OK;
        } else {
            context.terminal.writer().println(messageBuilderFactory.builder().error("Malformed encrypted string"));
            return BAD_OPERATION;
        }
    }

//
// This is a `MetricsLoaderFn`.
func loadNetworkInternodeMetrics(ctx context.Context, m MetricValues, _ *metricsCache) error {
	connStats := globalConnStats.toServerConnStats()
	rpcStats := rest.GetRPCStats()
	if globalIsDistErasure {
		m.Set(internodeErrorsTotal, float64(rpcStats.Errs))
		m.Set(internodeDialErrorsTotal, float64(rpcStats.DialErrs))
		m.Set(internodeDialAvgTimeNanos, float64(rpcStats.DialAvgDuration))

func LookupConfig(kvs config.KVS) (cfg Config, err error) {
	cfg = Config{
		TransitionWorkers: 100,
		ExpirationWorkers: 100,
	}

	if err = config.CheckValidKeys(config.ILMSubSys, kvs, DefaultKVS); err != nil {
		return cfg, err
	}

	tw, err := strconv.Atoi(env.Get(EnvILMTransitionWorkers, kvs.GetWithDefault(transitionWorkers, DefaultKVS)))
	if err != nil {
		return cfg, err
	}

    /**
     * Verify that the CRUD mode matches the expected mode.
     * Throws validation error if modes don't match.
     *
     * @param crudMode The current CRUD mode
     * @param expectedMode The expected CRUD mode
     * @param dictId The dictionary ID for error context
     */
    protected void verifyCrudMode(final int crudMode, final int expectedMode, final String dictId) {