} else { //member
                val classId = import.resolvedClassId ?: error("Class id should not be null as relativeClassName is not null")
                firScope.getStaticsScope(classId)?.getCallableNames().orEmpty()
            }
        }
    }

    ClassKind.ENUM_ENTRY -> invalidEnumEntryAsClassKind()
}

@KaAnalysisApiInternals
fun invalidEnumEntryAsClassKind(): Nothing {
    error("KtClassKind is not applicable for enum entry, as enum entry is a callable, not a classifier")

    }
}

/**
 * While the main declaration provider created via [createDeclarationProvider] is scope-based, there are other declaration providers which
 * are not, such as file-based declaration providers. Not all declarations provided by such declaration providers can be provided by the
 * main declaration provider, even if the correct scope is provided (such as a file-based scope). For example, the main declaration provider

        originalFile: KtFile,
        nameExpression: KtSimpleNameExpression,
        explicitReceiver: KtExpression?
    ): KaCompletionExtensionCandidateChecker {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    @Suppress("OVERRIDE_DEPRECATION")
    override fun checkExtensionFitsCandidate(
        firSymbolForCandidate: KaCallableSymbol,
        originalFile: KtFile,

 *
 * Engine services do not need to be implemented by a platform. Quite the contrary, they are implemented by the Analysis API engine and
 * intended to support platform implementations. They are defined in the Platform Interface, as opposed to the user-facing Analysis API,
 * because they are intended for the consumption of platform implementations, but not Analysis API users.
 *

            error("Not yet implemented")
        }

        override fun getChildren(): Array<VirtualFile> = emptyArray()

        override fun getInputStream(): InputStream {
            error("Not yet implemented")
        }

        override fun getOutputStream(requestor: Any?, newModificationStamp: Long, newTimeStamp: Long): OutputStream {
            error("Not yet implemented")
        }

     * change the return type of `z` as it does not have an explicit type. So, it is an **OOBM**.
     *
     * #### Example 2
     *
     * ```
     * val x: Int = 10<caret>
     * val z = x
     * ```
     *
     * If we change `10` to `"str"` as in the first example, it would not change the type of `z`, so it is not an **OOBM**.
     *

 */
public interface KotlinAnalysisPermissionOptions : KotlinOptionalPlatformComponent {
    /**
     * The default setting for [org.jetbrains.kotlin.analysis.api.permissions.KaAnalysisPermissionRegistry.isAnalysisAllowedOnEdt], when not
     * overridden by [org.jetbrains.kotlin.analysis.api.permissions.allowAnalysisOnEdt].
     *
     * TODO (KT-68186): Due to KT-68386, the implementation currently doesn't apply the default to

            // error is unfortunate, but to properly type this, we'd need to be able to restrict `KotlinCompositeProvider<P>` to be a
            // subtype of `P`, which is not possible in Kotlin.
            @Suppress("UNCHECKED_CAST")
            when (provider) {
                is KotlinCompositeProvider<*> -> (provider as KotlinCompositeProvider<P>).providers
                else -> listOf(provider)

import org.jetbrains.kotlin.psi.KtElement

/**
 * A service to match declarations with their annotations and vice versa.
 *
 * N.B. This service can produce both false positives and false negatives from time to time, since it might not be allowed to use
 * full-blown resolve to understand the true FqName of used annotation.
 *
 * The next statement should be `true` for any `annotation`:
 * ```
 * declarationsByAnnotation(annotation).all { declaration ->