import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.Project;
import org.gradle.api.tasks.bundling.Zip;

import java.util.Optional;

public class InternalPluginBuildPlugin implements InternalPlugin {
    @Override
    public void apply(Project project) {
        project.getPluginManager().apply(BuildPlugin.class);
        project.getPluginManager().apply(PluginBuildPlugin.class);

                CustomSizeValidator.class.getName());

        // Test that it implements ConstraintValidator
        assertTrue("Should implement ConstraintValidator",
                jakarta.validation.ConstraintValidator.class.isAssignableFrom(CustomSizeValidator.class));
    }

    @Test
    public void test_methodsExist() {

  }

  /** Returns the dummy return value for {@code returnType}. */
  abstract <R> @Nullable R dummyReturnValue(TypeToken<R> returnType);

  private final class DummyHandler extends AbstractInvocationHandler implements Serializable {
    private final TypeToken<?> interfaceType;

    DummyHandler(TypeToken<?> interfaceType) {
      this.interfaceType = interfaceType;
    }

    @Override

 *
 * @author Kurt Alfred Kluever
 * @since 12.0
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class ForwardingDeque<E extends @Nullable Object> extends ForwardingQueue<E>
    implements Deque<E> {

  /** Constructor for use by subclasses. */
  protected ForwardingDeque() {}

  @Override
  protected abstract Deque<E> delegate();

  @Override
  public void addFirst(@ParametricNullness E e) {

  }

  /*
   * This class is used to serialize ImmutableEnumMap instances.
   */
  @J2ktIncompatible // serialization
  private static final class EnumSerializedForm<K extends Enum<K>, V> implements Serializable {
    final EnumMap<K, V> delegate;

    EnumSerializedForm(EnumMap<K, V> delegate) {
      this.delegate = delegate;
    }

    Object readResolve() {

 *
 * This context is used during SMB2 negotiation to indicate RDMA transform
 * capabilities when SMB Direct is supported by the client and server.
 */
public class Smb2RdmaTransformCapabilitiesContext implements NegotiateContextRequest, NegotiateContextResponse {

    // Context type
    /** Context ID for RDMA transform capabilities */
    public static final int CONTEXT_ID = Smb2Constants.SMB2_RDMA_TRANSFORM_CAPABILITIES;

 * This structure contains basic file information including creation time, last access time, last write time,
 * change time, and file attributes for querying and setting file metadata.
 */
public class FileBasicInfo implements BasicFileInformation {

    private long createTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private int attributes;

    /**

                    session, trace, repository, artifacts, retryFailedDeploymentCount);
        }

        private static class DefaultArtifactDeployerRequest extends BaseRequest<Session>
                implements ArtifactDeployerRequest {

            private final RemoteRepository repository;
            private final Collection<ProducedArtifact> artifacts;
            private final int retryFailedDeploymentCount;

/**
 * Decrypts passwords in the settings.
 *
 * @deprecated since 4.0.0
 */
@Named
@Singleton
@Deprecated(since = "4.0.0")
public class DefaultSettingsDecrypter implements SettingsDecrypter {
    private final SecDispatcher securityDispatcher;

    @Inject
    public DefaultSettingsDecrypter(MavenSecDispatcher securityDispatcher) {
        this.securityDispatcher = securityDispatcher;

## Sobre Starlette { #about-starlette }

No deberías fijar la versión de `starlette`.

Diferentes versiones de **FastAPI** utilizarán una versión más reciente específica de Starlette.

Así que, puedes simplemente dejar que **FastAPI** use la versión correcta de Starlette.

## Sobre Pydantic { #about-pydantic }