return IndexedImmutableSet.this.isPartialView();
      }

      @Override
      public int size() {
        return IndexedImmutableSet.this.size();
      }

      @Override
      ImmutableCollection<E> delegateCollection() {
        return IndexedImmutableSet.this;
      }

      // redeclare to help optimizers with b/310253115
      @SuppressWarnings("RedundantOverride")
      @Override

      }
    };
  }

  @LazyInit @RetainedWith private transient @Nullable ImmutableCollection<V> values;

  /**
   * Returns an immutable collection of the values in this map, in the same order that they appear
   * in {@link #entrySet}.
   */
  @Override
  public ImmutableCollection<V> values() {
    ImmutableCollection<V> result = values;
    return (result == null) ? values = createValues() : result;
  }

 * A GWT-only class only used by GWT emulations. It is used to consolidate the definitions of method
 * delegation to save code size.
 *
 * @author Hayward Chan
 */
final class ForwardingImmutableCollection<E> extends ImmutableCollection<E> {

  final transient Collection<E> delegate;

  ForwardingImmutableCollection(Collection<E> delegate) {
    this.delegate = delegate;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

          }
        });
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.unsafeDelegate(delegate.keySet());
  }

  @Override
  ImmutableCollection<V> createValues() {
    return ImmutableCollection.unsafeDelegate(delegate.values());
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override

  public int size() {
    return 1;
  }

  @Override
  ImmutableSet<Cell<R, C, V>> createCellSet() {
    return ImmutableSet.of(cellOf(singleRowKey, singleColumnKey, singleValue));
  }

  @Override
  ImmutableCollection<V> createValues() {
    return ImmutableSet.of(singleValue);
  }

  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {

import org.jspecify.annotations.Nullable;

/**
 * An iterator that does not support {@link #remove}.
 *
 * <p>{@code UnmodifiableIterator} is used primarily in conjunction with implementations of {@link
 * ImmutableCollection}, such as {@link ImmutableList}. You can, however, convert an existing
 * iterator to an {@code UnmodifiableIterator} using {@link Iterators#unmodifiableIterator}.
 *
 * @author Jared Levy
 * @since 2.0
 */

  static <E> Collection<E> reserializeAndAssertElementsEqual(Collection<E> original) {
    Collection<E> copy = reserialize(original);
    assertTrue(elementsEqual(original, copy));
    assertTrue(copy instanceof ImmutableCollection);
    return copy;
  }

  private LenientSerializableTester() {}

   */
  public static <E> ImmutableList<E> copyOf(Collection<? extends E> elements) {
    if (elements instanceof ImmutableCollection) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableList<E> list = ((ImmutableCollection<E>) elements).asList();
      return list.isPartialView() ? asImmutableList(list.toArray()) : list;
    }
    return construct(elements.toArray());

    assertNotInstantiable(new TypeToken<ImmutableMultiset<EmptyEnum>>() {});
  }

  public void testImmutableCollection() {
    assertFreshInstance(new TypeToken<ImmutableCollection<String>>() {});
    assertNotInstantiable(new TypeToken<ImmutableCollection<EmptyEnum>>() {});
  }

  public void testImmutableMap() {
    assertFreshInstance(new TypeToken<ImmutableMap<String, Integer>>() {});
  }

      }

      @Override
      public K next() {
        return entryIterator.next().getKey();
      }
    };
  }

  private transient @Nullable ImmutableCollection<V> cachedValues = null;

  @Override
  public ImmutableCollection<V> values() {
    if (cachedValues != null) {
      return cachedValues;
    }
    return cachedValues = createValues();
  }