@Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CanIgnoreReturnValue
  public <T extends B> @Nullable T putInstance(

  }

  enum class Component {
    USER {
      override fun urlString(value: String): String = "http://$******@****.***/"

      override fun encodedValue(url: HttpUrl): String = url.encodedUsername

      override operator fun set(
        builder: HttpUrl.Builder,
        value: String,
      ) {
        builder.username(value)
      }

      override operator fun get(url: HttpUrl): String = url.username
    },

    @Override
    public String getProjectName() {
        return null;
    }

    @Override
    public String getProjectPrefix() {
        return null;
    }

    @Override
    public String getGenerationGapBasePrefix() {
        return null;
    }

    @Override
    public DBDef getCurrentDBDef() {
        return null;
    }

        .build(),
    )
    val asyncRequestBody: RequestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hello request!")
          sink.close()
        }

        override fun isDuplex(): Boolean = true
      }
    val request =
      request()
        .post(asyncRequestBody)

      }
      toRemove = -1;
    }
  }

  @Override
  Iterator<E> elementIterator() {
    return new Itr<E>() {
      @Override
      E output(int index) {
        return enumConstants[index];
      }
    };
  }

  @Override
  Iterator<Entry<E>> entryIterator() {
    return new Itr<Entry<E>>() {
      @Override
      Entry<E> output(int index) {

   * was retrieved.
   */
  @Override
  public Set<Multiset.Entry<E>> entrySet() {
    return super.entrySet();
  }

  @Override
  Iterator<E> elementIterator() {
    Iterator<Map.Entry<E, Count>> backingEntries = backingMap.entrySet().iterator();
    return new Iterator<E>() {
      Map.@Nullable Entry<E, Count> toRemove;

      @Override
      public boolean hasNext() {

      return obverse.removeInverse(obverseValue);
    }

    @Override
    public BiMap<K, V> inverse() {
      return obverse;
    }

    @Override
    public void clear() {
      obverse.clear();
    }

    @Override
    public Set<V> keySet() {
      return obverse.values();
    }

    @Override
    public Set<K> values() {
      return obverse.keySet();
    }

      @SuppressWarnings("RedundantOverride")
      @Override
      @J2ktIncompatible // serialization
      Object writeReplace() {
        return super.writeReplace();
      }
    };
  }

  @Override
  public int hashCode() {
    return asMapOfRanges().hashCode();
  }

  @Override
  public boolean equals(@Nullable Object o) {
    if (o instanceof RangeMap) {

        }
    }

    @Override
    public long getFilePointer() {
        return this.fp;
    }

    @Override
    public void seek(final long pos) {
        this.fp = pos;
    }

    @Override
    public long length() throws SmbException {
        return this.file.length();
    }

    @Override
    public void setLength(final long newLength) throws SmbException {

        @Override
        public void call(Listener listener) {
          listener.starting();
        }

        @Override
        public String toString() {
          return "starting()";
        }
      };
  private static final ListenerCallQueue.Event<Listener> RUNNING_EVENT =
      new ListenerCallQueue.Event<Listener>() {
        @Override
        public void call(Listener listener) {