override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) {
    logWithTime("satisfactionFailure: $response")
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit: $response")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheConditionalHit(
    call: Call,

  ) {
    logWithTime("satisfactionFailure")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit")
  }

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {
    logWithTime("cacheConditionalHit")
  }

import kotlin.reflect.KClass
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.Cache
import okhttp3.CallEvent
import okhttp3.CallEvent.CacheHit
import okhttp3.CallEvent.CacheMiss
import okhttp3.Dns
import okhttp3.EventRecorder
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.testing.PlatformRule
import okio.Buffer

    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

    ) {
      for (delegate in eventListeners) {
        delegate.satisfactionFailure(call, response)
      }
    }

    override fun cacheHit(
      call: Call,
      response: Response,
    ) {
      for (delegate in eventListeners) {
        delegate.cacheHit(call, response)
      }
    }

    override fun cacheMiss(call: Call) {
      for (delegate in eventListeners) {

    if (networkRequest == null) {
      return cacheResponse!!
        .newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build()
        .also {
          call.eventListener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {
      call.eventListener.cacheConditionalHit(call, cacheResponse)
    } else if (cache != null) {
      call.eventListener.cacheMiss(call)
    }

	public synthetic fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
	public fun cacheConditionalHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V
	public fun callFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun callStart (Lokhttp3/Call;)V

Ahora puedes añadir la extensión de ReDoc, agregando un `x-logo` personalizado al "objeto" `info` en el esquema de OpenAPI:

{* ../../docs_src/extending_openapi/tutorial001_py39.py hl[22:24] *}

### Cachear el esquema de OpenAPI { #cache-the-openapi-schema }

Puedes usar la propiedad `.openapi_schema` como un "cache", para almacenar tu esquema generado.

    val ioe: IOException,
  ) : CallEvent()

  data class SatisfactionFailure(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CacheHit(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class CacheMiss(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

	}

	info, err = p.storage.DiskInfo(ctx, opts)
	if err != nil {
		return info, err
	}

	// check cached diskID against backend
	// only if its non-empty.
	cachedID := *p.diskID.Load()
	if cachedID != "" && cachedID != info.ID {
		return info, errDiskNotFound
	}
	return info, nil
}

func (p *xlStorageDiskIDCheck) MakeVolBulk(ctx context.Context, volumes ...string) (err error) {