require(type is KtFirType)
        val coneType = type.coneType
        val substitutor = EnhancedForWarningConeSubstitutor(typeContext)
        val enhancedConeType = substitutor.substituteType(coneType)

        return enhancedConeType?.asKtType()
    }

    override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType {
        require(symbol is KtFirNamedClassOrObjectSymbol)

        require(symbol is KtFirSymbol<*>)
        return symbol.firSymbol.getDeprecationForCallSite(
            analysisSession.useSiteSession,
            AnnotationUseSiteTarget.PROPERTY_GETTER,
            AnnotationUseSiteTarget.PROPERTY,
        )

    }

    override fun getSetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
        require(symbol is KtFirSymbol<*>)

        require(type is KtFe10Type)
        return typeApproximator.approximateToSuperType(type.fe10Type, PublicApproximatorConfiguration(approximateLocalTypes))
            ?.toKtType(analysisContext)
    }

    override fun approximateToSubPublicDenotableType(type: KtType, approximateLocalTypes: Boolean): KtType? {
        require(type is KtFe10Type)

  }

private fun checkSupportResponse(
  name: String,
  response: Response?,
) {
  response?.apply {
    require(networkResponse == null) { "$name.networkResponse != null" }
    require(cacheResponse == null) { "$name.cacheResponse != null" }
    require(priorResponse == null) { "$name.priorResponse != null" }
  }
}

fun Response.Builder.commonPriorResponse(priorResponse: Response?) =
  apply {

      writeShort(0) // additional

      val nameBuf = Buffer()
      val labels = host.split('.').dropLastWhile { it.isEmpty() }
      for (label in labels) {
        val utf8ByteCount = label.utf8Size()
        require(utf8ByteCount == label.length.toLong()) { "non-ascii hostname: $host" }
        nameBuf.writeByte(utf8ByteCount.toInt())
        nameBuf.writeUtf8(label)
      }
      nameBuf.writeByte(0) // end

    override fun substitute(substitutor: KtSubstitutor): KtFirVariableLikeSignature<S> = withValidityAssertion {
        if (substitutor is KtSubstitutor.Empty) return@withValidityAssertion this
        require(substitutor is AbstractKtFirSubstitutor<*>)

        KtFirVariableLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, substitutor.substitutor)
    }
}

    }

    override fun substitute(substitutor: KtSubstitutor): KtFirFunctionLikeSignature<S> = withValidityAssertion {
        if (substitutor is KtSubstitutor.Empty) return@withValidityAssertion this
        require(substitutor is AbstractKtFirSubstitutor<*>)

        KtFirFunctionLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, substitutor.substitutor)
    }
}

        require(this is TypeConstructor)
        return when (this) {
            is NewTypeVariableConstructor -> originalTypeParameter != null
            else -> declarationDescriptor is TypeParameterDescriptor
        }
    }

    override fun TypeConstructorMarker.asTypeParameter(): TypeParameterMarker {
        require(this is TypeConstructor)
        return when (this) {

        require(first is KtFe10Type)
        require(second is KtFe10Type)
        return analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.fe10Type, second.fe10Type)
    }

    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean {
        require(subType is KtFe10Type)
        require(superType is KtFe10Type)

      apply {
        require(tls) { "no cipher suites for cleartext connections" }
        require(cipherSuites.isNotEmpty()) { "At least one cipher suite is required" }

        this.cipherSuites = cipherSuites.copyOf() as Array<String> // Defensive copy.
      }

    fun allEnabledTlsVersions() =
      apply {
        require(tls) { "no TLS versions for cleartext connections" }