class JavaNetAuthenticator : Authenticator {
  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? = JAVA_NET_AUTHENTICATOR.authenticate(route, response)

   *
   * The route is best effort, it currently may not always be provided even when logically
   * available. It may also not be provided when an authenticator is re-used manually in an
   * application interceptor, such as when implementing client-specific retries.
   */
  @Throws(IOException::class)
  fun authenticate(
    route: Route?,
    response: Response,
  ): Request?

    }
  }

  override fun connectStart(
    route: Route,
    call: Call,
  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  override fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) = logEvent(
    ConnectionEvent.ConnectFailed(System.nanoTime(), route, call, failure),
  )

  override fun connectEnd(

   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may
   * proceed to read the response body with [Response.body]. The response is still live until its

    // USED BY REMOTE RESOURCES PLUGIN, DEPENDENCY PLUGIN, SHADE PLUGIN
    @Deprecated
    void resolve(Artifact artifact, List<ArtifactRepository> remoteRepositories, ArtifactRepository localRepository)
            throws ArtifactResolutionException, ArtifactNotFoundException;

    // USED BY REMOTE RESOURCES PLUGIN
    @Deprecated
    void resolve(

/**
 * RDMA capability flags indicating what operations are supported
 * by an RDMA provider implementation.
 */
public enum RdmaCapability {
    /**
     * Remote direct read operations
     */
    RDMA_READ,

    /**
     * Remote direct write operations
     */
    RDMA_WRITE,

    /**
     * Traditional send/receive with RDMA
     */
    RDMA_SEND_RECEIVE,

    /**

            throws RepositoryMetadataResolutionException;

    /**
     * Deploy metadata to the remote repository.
     *
     * @param metadata             the metadata to deploy
     * @param localRepository      the local repository to install to first
     * @param deploymentRepository the remote repository to deploy to
     * @throws RepositoryMetadataDeploymentException in case of metadata deployment issue
     */

 *     when they are not available locally.</li>
 * </ul>
 *
 * <p>When resolving artifacts, Maven follows this order:</p><ol>
 * <li>Check Local Repository: Maven first checks if the artifact is available in the local repository.</li>

	return false
}

// Close - marks the client as closed.
func (c *lockRESTClient) Close() error {
	return nil
}

// String - returns the remote host of the connection.
func (c *lockRESTClient) String() string {
	return c.connection.Remote
}

func (c *lockRESTClient) call(ctx context.Context, h *grid.SingleHandler[*dsync.LockArgs, *dsync.LockResp], args *dsync.LockArgs) (ok bool, err error) {

The word "**server**" is commonly used to refer to both the remote/cloud computer (the physical or virtual machine) and also the program that is running on that machine (e.g. Uvicorn).

Just keep in mind that when you read "server" in general, it could refer to one of those two things.