import { GlobalConfigMain } from '@teambit/global-config';
import { Lane } from '@teambit/legacy/dist/scope/models';
import { IsolateComponentsOptions, IsolatorMain } from '@teambit/isolator';
import { AspectLoaderMain, AspectDefinition } from '@teambit/aspect-loader';
import { RequireableComponent } from '@teambit/harmony.modules.requireable-component';
import { ExtensionManifest, Aspect } from '@teambit/harmony';
import { Component, ComponentID, LoadAspectsOptions, ResolveAspectsOptions } from '@teambit/component';
import { Logger } from '@teambit/logger';
import { EnvsMain } from '@teambit/envs';
import { NodeLinker } from '@teambit/dependency-resolver';
import { ScopeMain } from './scope.main.runtime';
type ManifestOrAspect = ExtensionManifest | Aspect;
export type ScopeLoadAspectsOptions = LoadAspectsOptions & {
    useScopeAspectsCapsule?: boolean;
    packageManagerConfigRootDir?: string;
    workspaceName?: string;
};
export declare class ScopeAspectsLoader {
    private scope;
    private aspectLoader;
    private envs;
    private isolator;
    private logger;
    private globalConfig;
    constructor(scope: ScopeMain, aspectLoader: AspectLoaderMain, envs: EnvsMain, isolator: IsolatorMain, logger: Logger, globalConfig: GlobalConfigMain);
    loadAspects(ids: string[], throwOnError?: boolean, neededFor?: string, lane?: Lane, opts?: ScopeLoadAspectsOptions): Promise<string[]>;
    /**
     * This function get's a list of aspect ids and return them grouped by whether any of them is the env of other from the list
     * @param ids
     */
    groupAspectIdsByEnvOfTheList(ids: string[], lane?: Lane): Promise<{
        envs?: string[];
        other?: string[];
    }>;
    private getManifestsAndLoadAspects;
    getManifestsGraphRecursively(ids: string[], visited?: string[], throwOnError?: boolean, lane?: Lane, opts?: {
        packageManagerConfigRootDir?: string;
        workspaceName?: string;
        loadCustomEnvs?: string;
    }): Promise<{
        manifests: ManifestOrAspect[];
        potentialPluginsIds: string[];
    }>;
    private getNonLoadedAspects;
    getResolvedAspects(components: Component[], opts?: {
        skipIfExists?: boolean;
        packageManagerConfigRootDir?: string;
        workspaceName?: string;
    }): Promise<RequireableComponent[]>;
    private compileIfNoDist;
    private tryCompile;
    requireAspects(components: Component[], throwOnError?: boolean, opts?: {
        packageManagerConfigRootDir?: string;
        workspaceName?: string;
    }): Promise<Array<ExtensionManifest | Aspect>>;
    shouldUseDatedCapsules(): boolean;
    shouldCacheLockFileOnly(): boolean;
    getAspectCapsulePath(): string;
    shouldUseHashForCapsules(): boolean;
    getAspectsPackageManager(): string | undefined;
    getAspectsNodeLinker(): NodeLinker | undefined;
    private resolveUserAspects;
    resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
    getIsolateOpts(opts?: {
        skipIfExists?: boolean;
        packageManagerConfigRootDir?: string;
        workspaceName?: string;
    }): IsolateComponentsOptions;
    getDefaultIsolateOpts(): {
        datedDirId: string;
        baseDir: string;
        useHash: boolean;
        packageManager: string | undefined;
        nodeLinker: NodeLinker | undefined;
        useDatedDirs: boolean;
        cacheLockFileOnly: boolean;
        skipIfExists: boolean;
        seedersOnly: boolean;
        includeFromNestedHosts: boolean;
        host: ScopeMain;
        installOptions: {
            copyPeerToRuntimeOnRoot: boolean;
            useNesting: boolean;
            copyPeerToRuntimeOnComponents: boolean;
            installPeersFromEnvs: boolean;
        };
        context: {
            aspects: boolean;
        };
    };
}
export {};
