@KaAnalysisApiInternals
fun ClassKind.toKtClassKind(isCompanionObject: Boolean): KaClassKind = when (this) {
    ClassKind.INTERFACE -> KaClassKind.INTERFACE
    ClassKind.ENUM_CLASS -> KaClassKind.ENUM_CLASS
    ClassKind.ANNOTATION_CLASS -> KaClassKind.ANNOTATION_CLASS
    ClassKind.CLASS -> KaClassKind.CLASS
    ClassKind.OBJECT -> if (isCompanionObject) KaClassKind.COMPANION_OBJECT else KaClassKind.OBJECT

public enum class KaClassKind {
    CLASS,
    ENUM_CLASS,
    ANNOTATION_CLASS,
    OBJECT,
    COMPANION_OBJECT,
    INTERFACE,
    ANONYMOUS_OBJECT;

    public val isObject: Boolean get() = this == OBJECT || this == COMPANION_OBJECT || this == ANONYMOUS_OBJECT
    public val isClass: Boolean get() = this == CLASS || this == ANNOTATION_CLASS || this == ENUM_CLASS
}

                    return false
                }

                if (symbol.classKind == KaClassKind.ENUM_CLASS && superType.isClassTypeWithClassId(StandardClassIds.Enum)) {
                    return false
                }

                return true
            }
        }
    }

        }
    }

    override fun getEnumEntries(classSymbol: KaNamedClassOrObjectSymbol): List<KaEnumEntrySymbol> {
        require(classSymbol.classKind == KaClassKind.ENUM_CLASS)
        return with(analysisSession) {
            classSymbol.getStaticDeclaredMemberScope().getCallableSymbols().filterIsInstance<KaEnumEntrySymbol>().toList()
        }
    }

                    is KaPropertySymbol -> if (symbol.isOverride) return null
                    is KaConstructorSymbol -> {
                        if ((symbol.getContainingSymbol() as? KaClassOrObjectSymbol)?.classKind == KaClassKind.ENUM_CLASS) return null
                    }
                }

                return when (symbol.visibility) {
                    Visibilities.Public -> null
                    JavaVisibilities.PackageVisibility -> null

        val owner = with(analysisSession) {
            ownerPointer.restoreSymbol()
        }

        val enumClass = owner?.firSymbol?.fir as? FirRegularClass ?: return null
        if (enumClass.classKind != ClassKind.ENUM_CLASS) return null
        val enumEntry = enumClass.enumEntryByName(name) ?: return null
        return analysisSession.firSymbolBuilder.buildEnumEntrySymbol(enumEntry.symbol)
    }

        ) {
            printer {
                val keywords = when (symbol.classKind) {
                    KaClassKind.CLASS -> listOf(KtTokens.CLASS_KEYWORD)
                    KaClassKind.ENUM_CLASS -> listOf(KtTokens.ENUM_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.ANNOTATION_CLASS -> listOf(KtTokens.ANNOTATION_KEYWORD, KtTokens.CLASS_KEYWORD)

        val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
        if (enumDescriptor.kind != ClassKind.ENUM_CLASS) {
            return emptyList()
        }

        val result = mutableListOf<KaEnumEntrySymbol>()

        for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {

        get() = withValidityAssertion {
            val containingDescriptor = descriptor?.containingDeclaration
            if (containingDescriptor is ClassDescriptor && containingDescriptor.kind == ClassKind.ENUM_CLASS) {
                return containingDescriptor.defaultType.toKtType(analysisContext)
            } else {
                createErrorType()
            }
        }

    override val name: Name

    // Java static members, enums, and object members can be imported
    val canBeImported = containingClass.origin is FirDeclarationOrigin.Java && isStatic ||
            containingClass.classKind == ClassKind.ENUM_CLASS && isStatic ||
            containingClass.classKind == ClassKind.OBJECT

    return if (canBeImported) callableId.asSingleFqName() else null
}