*/
    public fun getAllSymbols(): Sequence<KaDeclarationSymbol> = withValidityAssertion {
        sequence {
            yieldAll(getCallableSymbols())
            yieldAll(getClassifierSymbols())
            yieldAll(getConstructors())
        }
    }

    /**
     * Return a sequence of [KaCallableSymbol] which current scope contain if declaration name matches [nameFilter].

     * Returns a **superset** of names which current scope may contain.
     * In other words `ALL_NAMES(scope)` is a subset of `scope.getAllNames()`
     */
    public fun getAllPossibleNames(): Set<Name> = withValidityAssertion {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }

    /**
     * Returns a **superset** of callable names which current scope may contain.

    /**
     * Return a sequence of [KaCallableSignature] which current scope contain if declaration name matches [nameFilter].
     */
    public fun getCallableSignatures(nameFilter: KaScopeNameFilter = { true }): Sequence<KaCallableSignature<*>>

    /**
     * Return a sequence of [KaCallableSignature] which current scope contain if declaration, if declaration name present in [names]
     *

     */
    public abstract val hasSpecificClassifierPackageNamesComputation: Boolean

    /**
     * Calculates the set of package names which contain classifiers and can be provided by this declaration provider.
     *
     * The set may contain false positives. `null` may be returned if the package set is too expensive or impossible to compute.
     */

    /**
     * Create a package provider for Kotlin/Native forward declaration packages in this [ktModule].
     *
     * @return a package provider for [ktModule] or `null` if the module cannot contain forward declarations
     */
    public abstract fun createPackageProvider(ktModule: KtModule): KotlinPackageProvider?

    public companion object {

    /**
     * Returns the set of top-level classifier (classes, interfaces, objects, and type-aliases) names in the file.
     *
     * The result may have false-positive entries but cannot have false-negative entries. It should contain all the names in the package but may have some additional names that are not there.
     *
     * @see KaResolveExtensionFile
     */
    public abstract fun getTopLevelClassifierNames(): Set<Name>

    /**

     * For other types of [KtModule]s the provider normally shouldn't be created.
     *
     * @return a declaration provider for [ktModule] or `null` if the module cannot contain forward declarations
     */
    public abstract fun createDeclarationProvider(ktModule: KtModule): KotlinDeclarationProvider?

    public companion object {

    /**
     * @param queriedAnnotation A qualified name of the annotation in question.
     * @return A set of PSI declarations which have [queriedAnnotation] declared directly on them.
     * Might contain both false positives and false negatives.
     */
    public fun declarationsByAnnotation(queriedAnnotation: ClassId): Set<KtAnnotated>

    /**

    @Override
    public List<String> getModelIds() {
        return modelIds;
    }

    public DefaultModelBuilderResult addModelId(String modelId) {
        // Intentionally notNull because Super POM may not contain a modelId
        Objects.requireNonNull(modelId, "modelId cannot be null");

        modelIds.add(modelId);

        return this;
    }

    @Override
    public Model getRawModel() {

     * Returns the file paths of all dependencies, regardless on which tool option those paths should be placed.
     * The returned list may contain a mix of Java class-path, Java module-path, and other types of path elements.
     * This collection has the same content than {@code getDependencies.values()} except that it does not contain
     * null elements.
     *
     * @return the paths of all dependencies
     */
    @Nonnull
    List<Path> getPaths();