*/
    @Nonnull
    String getLocation();

    /**
     * Returns a new source identified by a relative path. Implementation <strong>MUST</strong>
     * be able to accept <code>relative</code> parameter values that
     * <ul>
     * <li>use either / or \ file path separator,</li>
     * <li>have .. parent directory references,</li>
     * <li>point either at file or directory.</li>

And **FastAPI**'s `HTTPException` error class inherits from Starlette's `HTTPException` error class.

The only difference is that **FastAPI**'s `HTTPException` accepts any JSON-able data for the `detail` field, while Starlette's `HTTPException` only accepts strings for it.

So, you can keep raising **FastAPI**'s `HTTPException` as normally in your code.

                        version);
            }
            String newVersion = versions.get(versions.size() - 1).asString();
            if (!version.equals(newVersion)) {
                resolvedVersion.accept(newVersion);
            }

            Map.Entry<org.apache.maven.api.Artifact, Path> resolved =
                    session.resolveArtifact(session.createArtifactCoordinate(groupId, artifactId, newVersion, "pom"));

                            e);
        }
        project.setRemoteArtifactRepositories(remoteRepositories);

        if (model.getDelegate() != event.model()) {
            event.update().accept(model.getDelegate());
        }
    }

}

func (s *sftpLogger) Error(tag xsftp.LogType, err error) {
	switch tag {
	case xsftp.AcceptNetworkError:
		sftpLogOnceIf(context.Background(), err, "accept-limit-sftp")
	case xsftp.AcceptChannelError:
		sftpLogOnceIf(context.Background(), err, "accept-channel-sftp")
	case xsftp.SSHKeyExchangeError:
		sftpLogOnceIf(context.Background(), err, "key-exchange-sftp")
	default:

   * @return an unmodifiable version of the input which will not hang the JVM
   */
  @J2ktIncompatible
  @GwtIncompatible // TODO
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static ExecutorService getExitingExecutorService(
      ThreadPoolExecutor executor, long terminationTimeout, TimeUnit timeUnit) {

   *       Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
   *       function.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this function does not accept null
   *     arguments
   */
  @ParametricNullness
  T apply(@ParametricNullness F input);

  /**
   * <i>May</i> return {@code true} if {@code object} is a {@code Function} that behaves identically

      )
    }

    val headerAccept = response.header("Sec-WebSocket-Accept")
    val acceptExpected = (key + WebSocketProtocol.ACCEPT_MAGIC).encodeUtf8().sha1().base64()
    if (acceptExpected != headerAccept) {
      throw ProtocolException(
        "Expected 'Sec-WebSocket-Accept' header value '$acceptExpected' but was '$headerAccept'",
      )
    }

    if (exchange == null) {

    portField = serverSocket!!.localPort

    taskRunner.newQueue().execute("MockWebServer $portField", cancelable = false) {
      try {
        logger.fine("$this starting to accept connections")
        acceptConnections()
      } catch (e: Throwable) {
        logger.log(Level.WARNING, "$this failed unexpectedly", e)
      }

  }

  private fun doServerHandshake(server: HandshakeCertificates): Future<Handshake> {
    return executorService.submit<Handshake> {
      serverSocket!!.accept().use { rawSocket ->
        val sslSocket =
          server.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,