if (queryNamesAndValues == null) return emptySet()
      val result = LinkedHashSet<String>()
      for (i in 0 until queryNamesAndValues.size step 2) {
        result.add(queryNamesAndValues[i]!!)
      }
      return result.readOnly()
    }

  /**
   * Returns all values for the query parameter `name` ordered by their appearance in this
   * URL. For example this returns `["banana"]` for `queryParameterValue("b")` on

        val propertyReferenceExpression = firPropertyAccess.correspondingNameReference ?: return
        val qualifiedProperty = propertyReferenceExpression.getQualifiedElement() as? KtDotQualifiedExpression ?: return

        if (!qualifiedProperty.inSelection) return

        val propertySymbol = firPropertyAccess.referencedSymbol ?: return

    Create duplex calls by overriding the new `RequestBody.isDuplex()` method to return true.
    This simple option dramatically changes the behavior of the request body and of the entire
    call.

    The `RequestBody.writeTo()` method may now retain a reference to the provided sink and
    hand it off to another thread to write to it after `writeTo` returns.

 */
open class OkHttpClient internal constructor(
  builder: Builder,
) : Call.Factory, WebSocket.Factory {
  @get:JvmName("dispatcher")
  val dispatcher: Dispatcher = builder.dispatcher

  /**
   * Returns an immutable list of interceptors that observe the full span of each call: from before
   * the connection is established (if any) until after the response source is selected (either the
   * origin server, cache, or both).
   */

message TableOptions {
  // includeObject decides whether to include each object along with its columnar information.
  // Specifying "None" will return no object, specifying "Object" will return the full object contents, and
  // specifying "Metadata" (the default) will return the object's metadata in the PartialObjectMetadata kind
  // in version v1beta1 of the meta.k8s.io API group.
  optional string includeObject = 1;
}

        if (this !is KtExpression) return null
        val calleeExpression = deparenthesize(this) ?: return null
        if (calleeExpression is KtCallExpression) return null
        val callExpression = parentOfType<KtCallExpression>() ?: return null
        if (deparenthesize(callExpression.calleeExpression) != calleeExpression) return null
        return callExpression
    }

    /**

    for (log in logs) {
      if (type in log) {
        return log
      }
    }
    return null
  }

  private fun countFrames(
    logs: List<String>,
    message: String,
  ): Int {
    var result = 0
    for (log in logs) {
      if (log == message) {
        result++
      }
    }
    return result
  }

  /**

    return object : BaseMatcher<Long?>() {
      override fun describeTo(description: Description?) {
        description!!.appendText("> $value")
      }

      override fun matches(o: Any?): Boolean {
        return (o as Long?)!! > value
      }
    }
  }

  private fun matchesProtocol(protocol: Protocol?): Matcher<Response?> {
    return object : BaseMatcher<Response?>() {

        result.add(line)
      }
    }
    return result
  }

  private fun getCleanFile(
    key: String,
    index: Int,
  ) = cacheDir / "$key.$index"

  private fun getDirtyFile(
    key: String,
    index: Int,
  ) = cacheDir / "$key.$index.tmp"

  private fun readFile(file: Path): String {
    return filesystem.read(file) {
      readUtf8()
    }
  }

    assertThat(ackFrame.streamId).isEqualTo(0)
    assertThat(ackFrame.ack).isTrue()
    return connection
  }

  private class RecordingPushObserver : PushObserver {
    val events = mutableListOf<Any>()

    @Synchronized fun takeEvent(): Any {
      while (events.isEmpty()) {
        wait()
      }
      return events.removeAt(0)
    }

    @Synchronized override fun onRequest(