}

    override fun canBeNull(type: KtType): Boolean {
        require(type is KtFe10Type)
        return TypeUtils.isNullableType(type.fe10Type)
    }

    override fun isDenotable(type: KtType): Boolean {
        require(type is KtFe10Type)
        val kotlinType = type.fe10Type
        return kotlinType.isDenotable()
    }

    override fun isArrayOrPrimitiveArray(type: KtType): Boolean {

        get() = branchName == EXPERIMENTAL_BRANCH

    fun vcsRootId() = DslContext.settingsRoot.id.toString()

    fun promoteNightlyTaskName() = nightlyTaskName("promote")
    fun prepNightlyTaskName() = nightlyTaskName("prep")

    fun promoteMilestoneTaskName(): String = when {
        isRelease -> "promoteReleaseMilestone"
        else -> "promoteMilestone"
    }

    fun promoteFinalReleaseTaskName(): String = when {

    level = DeprecationLevel.ERROR,
  )
  fun localPrincipal(): Principal? = localPrincipal

  override fun equals(other: Any?): Boolean {
    return other is Handshake &&
      other.tlsVersion == tlsVersion &&
      other.cipherSuite == cipherSuite &&
      other.peerCertificates == peerCertificates &&
      other.localCertificates == localCertificates
  }

  override fun hashCode(): Int {
    var result = 17

   */
  fun enqueue(responseCallback: Callback)

  /** Cancels the request, if possible. Requests that are already complete cannot be canceled. */
  fun cancel()

  /**
   * Returns true if this call has been either [executed][execute] or [enqueued][enqueue]. It is an
   * error to execute a call more than once.
   */
  fun isExecuted(): Boolean

  fun isCanceled(): Boolean

  /**

            // cannot do so:
            // ```
            // fun x(c: Char) {}
            // fun call(x: kotlin.Int) {
            //   operator fun Int.invoke(a: Int) {}
            //   operator fun Int.invoke(b: Boolean) {}
            //   <expr>x()</expr>
            // }
            // ```

        return samResolver.isSamType(coneType)
    }

    override fun getFunctionClassKind(type: KtType): FunctionTypeKind? {
        return (type as KtFirType).coneType.functionTypeKind(analysisSession.useSiteSession)
    }

    override fun canBeNull(type: KtType): Boolean = (type as KtFirType).coneType.canBeNull(analysisSession.useSiteSession)

    override fun isDenotable(type: KtType): Boolean {

   */
  fun newBuilder(link: String): Builder? {
    return try {
      Builder().parse(this, link)
    } catch (_: IllegalArgumentException) {
      null
    }
  }

  override fun equals(other: Any?): Boolean {
    return other is HttpUrl && other.url == url
  }

  override fun hashCode(): Int = url.hashCode()

  override fun toString(): String = url

  /**

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  override fun peek(): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueueResponse(response.wrap())
  }

  override fun shutdown() {
    delegate.shutdown()
  }

        }
    }

    private fun FirCallableDeclaration.isDeclared(): Boolean =
        symbol.callableId.classId == owner.classId
                && origin !is FirDeclarationOrigin.SubstitutionOverride
                && origin != FirDeclarationOrigin.IntersectionOverride

    private fun FirRegularClass.isDeclared(): Boolean = symbol.classId.parentClassId == owner.classId

   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**
   * Invoked as soon as a connection is successfully established.
   */
  open fun connectEnd(
    connection: Connection,