import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nullable;

/**
 * A dependency exclusion.
 *
 * @since 4.0.0
 * @see DependencyCoordinates#getExclusions()
 */
@Experimental
public interface Exclusion {
    @Nullable
    String getGroupId();

    @Nullable
    String getArtifactId();

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {

  @Override
  public <T extends B> @Nullable T putInstance(
      Class<@NonNull T> type, @ParametricNullness T value) {
    return cast(type, put(type, value));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return cast(type, get(type));
  }

  @CanIgnoreReturnValue
  private static <T> @Nullable T cast(Class<T> type, @Nullable Object value) {

            Tables.<@Nullable Object, @Nullable Object, @Nullable Object>immutableCell(
                null, null, null))
        .addEqualityGroup(
            Tables.<String, @Nullable Object, @Nullable Object>immutableCell("bar", null, null))
        .addEqualityGroup(
            Tables.<@Nullable Object, Integer, @Nullable Object>immutableCell(null, 2, null))
        .addEqualityGroup(

   */
  static @Nullable String emptyToNull(@Nullable String string) {
    return stringIsNullOrEmpty(string) ? null : string;
  }

  static String lenientFormat(@Nullable String template, @Nullable Object @Nullable ... args) {
    return Strings.lenientFormat(template, args);
  }

  static String stringValueOf(@Nullable Object o) {
    return String.valueOf(o);
  }

   */
  static <T extends @Nullable Object> T[] toArrayImpl(
      @Nullable Object[] src, int offset, int len, T[] dst) {
    checkPositionIndexes(offset, offset + len, src.length);
    if (dst.length < len) {
      dst = newArray(dst, len);
    } else if (dst.length > len) {
      @Nullable Object[] unsoundlyCovariantArray = dst;
      unsoundlyCovariantArray[len] = null;
    }

public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

import java.util.concurrent.Future;
import org.jspecify.annotations.Nullable;

/**
 * Transforms a value, possibly asynchronously. For an example usage and more information, see
 * {@link Futures#transformAsync(ListenableFuture, AsyncFunction, Executor)}.
 *
 * @author Chris Povirk
 * @since 11.0
 */
@GwtCompatible
public interface AsyncFunction<I extends @Nullable Object, O extends @Nullable Object> {
  /**

package com.google.common.util.concurrent;

import static com.google.common.collect.Sets.newHashSet;

import java.util.Set;
import org.jspecify.annotations.Nullable;

/** Emulation of AggregateFutureState. */
abstract class AggregateFutureState<OutputT extends @Nullable Object>
    extends AbstractFuture.TrustedFuture<OutputT> {
  // Lazily initialized the first time we see an exception; not released until all the input futures

  }

  private static Iterable<@Nullable Object> iterable(
      @Nullable Object first, @Nullable Object second, @Nullable Object[] rest) {
    checkNotNull(rest);
    return new AbstractList<@Nullable Object>() {
      @Override
      public int size() {
        return rest.length + 2;
      }

      @Override
      public @Nullable Object get(int index) {
        switch (index) {