?: errorWithFirSpecificEntries("Class was not found", coneType = coneType)
    }
    override val typeArguments: List<KaTypeProjection> get() = withValidityAssertion { qualifiers.last().typeArguments }

    override val qualifiers: List<KaClassTypeQualifier.KaResolvedClassTypeQualifier> by cached {
        UsualClassTypeQualifierBuilder.buildQualifiers(coneType, builder)
    }

    }

    static class TestNodeIdentity implements NodeIdentity {
        NodeType nodeType
        String name

        TestNodeIdentity(NodeType nodeType, String name) {
            this.nodeType = nodeType
            this.name = name
        }

        @Override
        NodeType getNodeType() {
            return nodeType
        }

        @Override
        String toString() {

// to be fully set up.
func under(t Type) Type {
	if t := asNamed(t); t != nil {
		return t.under()
	}
	return t.Underlying()
}

// If t is not a type parameter, coreType returns the underlying type.
// If t is a type parameter, coreType returns the single underlying
// type of all types in its type set if it exists, or nil otherwise. If the
// type set contains only unrestricted and restricted channel types (with

    }

    override fun canBeNull(type: KaType): Boolean = (type as KaFirType).coneType.canBeNull(analysisSession.useSiteSession)

    override fun isDenotable(type: KaType): Boolean {
        val coneType = (type as KaFirType).coneType
        return analysisSession.useSiteSession.typeApproximator.approximateToSuperType(
            coneType,

			<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.sheet.3"</arg>
		</postConstruct>
		<postConstruct name="addCondition">
			<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.sheet.4"</arg>
		</postConstruct>
		<postConstruct name="addCondition">
			<arg>"mimetype"</arg>
			<arg>"application/vnd.ms-excel.workspace.3"</arg>
		</postConstruct>
		<postConstruct name="addCondition">
			<arg>"mimetype"</arg>

    public void addMaxLength(final String mimeType, final long maxLength) {
        if (StringUtil.isBlank(mimeType)) {
            throw new CrawlerSystemException("MIME type is a blank.");
        }
        if (maxLength < 0) {
            throw new CrawlerSystemException("The value of maxLength is invalid.");
        }
        maxLengthMap.put(mimeType, maxLength);
    }

    override fun approximateToSuperPublicDenotableType(type: KaType, approximateLocalTypes: Boolean): KaType? {
        require(type is KaFirType)
        val coneType = type.coneType
        val approximatedConeType = PublicTypeApproximator.approximateTypeToPublicDenotable(
            coneType,
            rootModuleSession,
            approximateLocalTypes = approximateLocalTypes,
        )

        return approximatedConeType?.asKtType()

        return analysisSession.useSiteSession.jvmTypeMapper.mapType(type.coneType, mode, sw = null, unresolvedQualifierRemapper = null)
    }

    override fun isPrimitiveBacked(type: KaType): Boolean {
        return analysisSession.useSiteSession.jvmTypeMapper.isPrimitiveBacked(type.coneType)
    }

    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }
    override val nullability: KaTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }

    override val abbreviatedType: KaUsualClassType?
        get() = withValidityAssertion { null }

    override fun equals(other: Any?) = typeEquals(other)

internal class KaFirCapturedType(
    override val coneType: ConeCapturedType,
    private val builder: KaSymbolByFirBuilder,
) : KaCapturedType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token
    override val nullability: KaTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }

    override val projection: KaTypeProjection