import { type Catalogs } from '@pnpm/catalogs.types';
import { type LockfileObject } from '@pnpm/lockfile.types';
import { type PatchGroupRecord } from '@pnpm/patching.config';
import { type PreferredVersions, type Resolution, type WorkspacePackages } from '@pnpm/resolver-base';
import { type StoreController } from '@pnpm/store-controller-types';
import { type AllowBuild, type SupportedArchitectures, type AllowedDeprecatedVersions, type PinnedVersion, type PkgResolutionId, type ProjectManifest, type ProjectId, type ReadPackageHook, type Registries, type ProjectRootDir, type TrustPolicy } from '@pnpm/types';
import { type WantedDependency } from './getNonDevWantedDependencies.js';
import { type NodeId } from './nextNodeId.js';
import { type DependenciesTree, type LinkedDependency, type ResolvedPackage, type ResolvedPkgsById } from './resolveDependencies.js';
export type { LinkedDependency, ResolvedPackage, DependenciesTree, DependenciesTreeNode } from './resolveDependencies.js';
export interface ResolvedImporters {
    [id: string]: {
        directDependencies: ResolvedDirectDependency[];
        directNodeIdsByAlias: Map<string, NodeId>;
        linkedDependencies: LinkedDependency[];
    };
}
export interface ResolvedDirectDependency {
    alias: string;
    optional: boolean;
    dev: boolean;
    resolution: Resolution;
    pkgId: PkgResolutionId;
    version: string;
    name: string;
    catalogLookup?: CatalogLookupMetadata;
    normalizedBareSpecifier?: string;
}
/**
 * Information related to the catalog entry for this dependency if it was
 * requested through the catalog protocol.
 */
export interface CatalogLookupMetadata {
    readonly catalogName: string;
    readonly specifier: string;
    /**
     * The catalog protocol bareSpecifier the user wrote in package.json files or as a
     * parameter to pnpm add. Ex: pnpm add foo@catalog:
     *
     * This will usually be 'catalog:<name>', but can simply be 'catalog:' if
     * users wrote the default catalog shorthand. This is different than the
     * catalogName field, which would be 'default' regardless of whether users
     * originally requested 'catalog:' or 'catalog:default'.
     */
    readonly userSpecifiedBareSpecifier: string;
}
export interface Importer<WantedDepExtraProps> {
    id: ProjectId;
    manifest: ProjectManifest;
    modulesDir: string;
    removePackages?: string[];
    rootDir: ProjectRootDir;
    wantedDependencies: Array<WantedDepExtraProps & WantedDependency>;
}
export interface ImporterToResolveGeneric<WantedDepExtraProps> extends Importer<WantedDepExtraProps> {
    updatePackageManifest: boolean;
    updateMatching?: (pkgName: string) => boolean;
    updateToLatest?: boolean;
    hasRemovedDependencies?: boolean;
    preferredVersions?: PreferredVersions;
    wantedDependencies: Array<WantedDepExtraProps & WantedDependency & {
        updateDepth: number;
    }>;
    pinnedVersion?: PinnedVersion;
}
export interface ResolveDependenciesOptions {
    allowBuild?: AllowBuild;
    autoInstallPeers?: boolean;
    autoInstallPeersFromHighestMatch?: boolean;
    allowedDeprecatedVersions: AllowedDeprecatedVersions;
    allowUnusedPatches: boolean;
    catalogs?: Catalogs;
    currentLockfile: LockfileObject;
    dedupePeerDependents?: boolean;
    dryRun: boolean;
    engineStrict: boolean;
    force: boolean;
    forceFullResolution: boolean;
    ignoreScripts?: boolean;
    hooks: {
        readPackage?: ReadPackageHook;
    };
    nodeVersion?: string;
    registries: Registries;
    patchedDependencies?: PatchGroupRecord;
    pnpmVersion: string;
    preferredVersions?: PreferredVersions;
    preferWorkspacePackages?: boolean;
    resolutionMode?: 'highest' | 'time-based' | 'lowest-direct';
    resolvePeersFromWorkspaceRoot?: boolean;
    injectWorkspacePackages?: boolean;
    linkWorkspacePackagesDepth?: number;
    lockfileDir: string;
    storeController: StoreController;
    tag: string;
    virtualStoreDir: string;
    virtualStoreDirMaxLength: number;
    wantedLockfile: LockfileObject;
    workspacePackages: WorkspacePackages;
    supportedArchitectures?: SupportedArchitectures;
    peersSuffixMaxLength: number;
    minimumReleaseAge?: number;
    minimumReleaseAgeExclude?: string[];
    trustPolicy?: TrustPolicy;
    trustPolicyExclude?: string[];
    trustPolicyIgnoreAfter?: number;
    blockExoticSubdeps?: boolean;
}
export interface ResolveDependencyTreeResult {
    allPeerDepNames: Set<string>;
    dependenciesTree: DependenciesTree<ResolvedPackage>;
    outdatedDependencies: {
        [pkgId: string]: string;
    };
    resolvedImporters: ResolvedImporters;
    resolvedPkgsById: ResolvedPkgsById;
    wantedToBeSkippedPackageIds: Set<string>;
    appliedPatches: Set<string>;
    time?: Record<string, string>;
}
export declare function resolveDependencyTree<T>(importers: Array<ImporterToResolveGeneric<T>>, opts: ResolveDependenciesOptions): Promise<ResolveDependencyTreeResult>;