public boolean contains(@CheckForNull Object object) {
    return forward.contains(object);
  }

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

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {
    return forward.tailSet(toElement, inclusive).descendingSet();
  }

              append(" body)")
            },
          )
        }
      }

      return response
    }

    internal fun redactUrl(url: HttpUrl): String {
      if (queryParamsNameToRedact.isEmpty() || url.querySize == 0) {
        return url.toString()
      }
      return url.newBuilder().query(null).apply {
        for (i in 0 until url.querySize) {

          }
        listener.onFailure(this, exception, response)
        return
      }
      if (canceled) {
        listener.onFailure(this, IOException("canceled"), response)
      } else {
        listener.onClosed(this)
      }
    }
  }

  private fun ResponseBody.isEventStream(): Boolean {
    val contentType = contentType() ?: return false
    return contentType.type == "text" && contentType.subtype == "event-stream"
  }

        return asJson(new ApiResult.ApiPluginResponse().plugins(list).status(ApiResult.Status.OK).result());
    }

    // GET /api/admin/plugin/available
    @Execute
    public JsonResponse<ApiResult> get$available() {
        final List<Map<String, String>> list = getAllAvailableArtifacts();

    private static final String ITEM_ENDPOINT_SUFFIX = "setting";

    @Override
    protected String getListEndpointSuffix() {
        return LIST_ENDPOINT_SUFFIX + "/" + dictId;
    }

    @Override
    protected String getItemEndpointSuffix() {
        return ITEM_ENDPOINT_SUFFIX + "/" + dictId;
    }

    @BeforeEach
    protected void initializeDictId() {

                    return;
                }
            }
            throw new DcerpcException("Bad endpoint: " + endpoint);
        }
        if (options == null)
            options = new HashMap();
        options.put(key, val);
    }
    Object getOption(String key) {
        if (key.equals("endpoint"))
            return endpoint;
        if (options != null)

            .createTestSuite());

    suite.addTestSuite(ImmutableSetTest.class);

    return suite;
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> of() {
    return ImmutableSet.of();
  }

  @Override
  protected <E extends Comparable<? super E>> Set<E> of(E e) {
    return ImmutableSet.of(e);
  }

  @Override

    this.options = ImmutableSet.copyOf(options);
  }

  byte[] getBytes() {
    return bytes.toByteArray();
  }

  @Override
  public boolean wasStreamOpened() {
    return outputStreamOpened;
  }

  @Override
  public boolean wasStreamClosed() {
    return outputStreamClosed;
  }

  @Override
  public OutputStream openStream() throws IOException {

 */
public interface SmbSessionInternal extends SmbSession {

    /**
     * @return whether the session is in use
     */
    boolean isInUse ();


    /**
     * @return the current session key
     * @throws CIFSException
     */
    byte[] getSessionKey () throws CIFSException;


    /**
     * 
     * @return the transport for this session
     */
    SmbTransport getTransport ();


    /**

    session.add(hero)
    session.commit()
    session.refresh(hero)
    return hero


@app.get("/heroes/")
def read_heroes(
    session: SessionDep,
    offset: int = 0,
    limit: Annotated[int, Query(le=100)] = 100,
) -> list[Hero]:
    heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
    return heroes


@app.get("/heroes/{hero_id}")