* It extends the Serializable interface to allow sitemap objects to be serialized.
 */
public interface Sitemap extends Serializable {

    /**
     * Retrieves the location (URL) of the sitemap.
     *
     * @return the location of the sitemap as a String.
     */
    String getLoc();

    /**
     * Retrieves the last modification date of the sitemap.
     *

   * Configure the ApplicationContext. Not needed unless the AndroidX Startup [Initializer] is disabled, or running
   * a robolectric test.
   *
   * The functionality that will fail without a valid Context is primarily Cookies and URL Domain handling, but
   * may expand in the future.
   */
  fun initialize(applicationContext: Context) {
    if (PlatformRegistry.applicationContext == null) {
      // Make sure we aren't using an Activity or Service Context

      OkHttpClient
        .Builder()
        .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("https://www.google.ca/")
          .build(),
      )
    val response = call.execute()
    try {
      println(response.code)
      println("PROTOCOL ${response.protocol}")
      var line: String?

import okhttp3.RequestBody.Companion.asRequestBody

class PostFile {
  private val client = OkHttpClient()

  fun run() {
    val file = File("README.md")

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = file.asRequestBody(MEDIA_TYPE_MARKDOWN),
      )

    client.newCall(request).execute().use { response ->

                return false;
            }

            @Override
            public String encodeURL(String url) {
                return url;
            }

            @Override
            public String encodeRedirectURL(String url) {
                return url;
            }

            @Override
            public void sendError(int sc, String msg) {
            }

pkg net/http/httputil, type BufferPool interface, Put([]uint8)
pkg net/http/httputil, type ReverseProxy struct, BufferPool BufferPool
pkg net/url, method (*Error) Temporary() bool
pkg net/url, method (*Error) Timeout() bool
pkg net/url, method (InvalidHostError) Error() string
pkg net/url, type InvalidHostError string
pkg os/exec, type ExitError struct, Stderr []uint8
pkg regexp, method (*Regexp) Copy() *Regexp

	authTypeStreamingSignedTrailer
	authTypeStreamingUnsignedTrailer
)

// Get request authentication type.
func getRequestAuthType(r *http.Request) (at authType) {
	if r.URL != nil {
		var err error
		r.Form, err = url.ParseQuery(r.URL.RawQuery)
		if err != nil {
			authNLogIf(r.Context(), err)
			return authTypeUnknown
		}
	}
	if isRequestSignatureV2(r) {
		return authTypeSignedV2

  fun setServerSocketFactory(serverSocketFactory: ServerSocketFactory) {
    delegate.serverSocketFactory = serverSocketFactory
  }

  fun url(path: String): HttpUrl {
    before() // This implicitly starts the delegate.
    return delegate.url(path)
  }

  @JvmName("-deprecated_bodyLimit")
  fun setBodyLimit(bodyLimit: Long) {
    delegate.bodyLimit = bodyLimit
  }

También defines de alguna manera en qué **momentos** tu aplicación enviará esas requests o eventos.

Y **tus usuarios** definen de alguna manera (por ejemplo en un panel web en algún lugar) el **URL** donde tu aplicación debería enviar esas requests.

Toda la **lógica** sobre cómo registrar los URLs para webhooks y el código para realmente enviar esas requests depende de ti. Lo escribes como quieras en **tu propio código**.

              println("Negotiated " + sslSocket.applicationProtocol)
            }
          },
        ).build()

    val request =
      Request
        .Builder()
        .url("https://www.google.com")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
    }
  }