import { type CatalogResolver } from '@pnpm/catalogs.resolver';
import { type LockfileObject, type PackageSnapshot, type ResolvedDependencies } from '@pnpm/lockfile.types';
import { type PatchGroupRecord } from '@pnpm/patching.config';
import { type DirectoryResolution, type PreferredVersions, type Resolution, type WorkspacePackages, type PkgResolutionId } from '@pnpm/resolver-base';
import { type PkgRequestFetchResult, type PackageResponse, type StoreController } from '@pnpm/store-controller-types';
import { type AllowBuild, type SupportedArchitectures, type AllowedDeprecatedVersions, type PackageManifest, type ReadPackageHook, type Registries, type PkgIdWithPatchHash, type PinnedVersion, type PackageVersionPolicy, type TrustPolicy } from '@pnpm/types';
import { type PatchInfo } from '@pnpm/patching.types';
import { type WantedDependency } from './getNonDevWantedDependencies.js';
import { type NodeId } from './nextNodeId.js';
import { type CatalogLookupMetadata } from './resolveDependencyTree.js';
export type { WantedDependency };
export declare function getPkgsInfoFromIds(ids: PkgResolutionId[], resolvedPkgsById: ResolvedPkgsById): Array<{
    id: PkgResolutionId;
    name: string;
    version: string;
}>;
export interface ChildrenMap {
    [alias: string]: NodeId;
}
export type DependenciesTreeNode<T> = {
    children: (() => ChildrenMap) | ChildrenMap;
    installable: boolean;
} & ({
    resolvedPackage: T & {
        name: string;
        version: string;
    };
    depth: number;
} | {
    resolvedPackage: {
        name: string;
        version: string;
    };
    depth: -1;
});
export type DependenciesTree<T> = Map<NodeId, DependenciesTreeNode<T>>;
export type ResolvedPkgsById = Record<PkgResolutionId, ResolvedPackage>;
export interface PkgAddressOrLinkBase {
    alias: string;
    catalogLookup?: CatalogLookupMetadata;
    normalizedBareSpecifier?: string;
    optional: boolean;
    pkg: PackageManifest;
    pkgId: PkgResolutionId;
}
export interface LinkedDependency extends PkgAddressOrLinkBase {
    isLinkedDependency: true;
    dev: boolean;
    resolution: DirectoryResolution;
    version: string;
    name: string;
}
export interface PendingNode {
    alias: string;
    nodeId: NodeId;
    resolvedPackage: ResolvedPackage;
    depth: number;
    installable: boolean;
    parentIds: PkgResolutionId[];
}
export interface ChildrenByParentId {
    [id: PkgResolutionId]: Array<{
        alias: string;
        id: PkgResolutionId;
    }>;
}
export interface ResolutionContext {
    allowBuild?: AllowBuild;
    allPeerDepNames: Set<string>;
    autoInstallPeers: boolean;
    autoInstallPeersFromHighestMatch: boolean;
    allowedDeprecatedVersions: AllowedDeprecatedVersions;
    allPreferredVersions?: PreferredVersions;
    appliedPatches: Set<string>;
    updatedSet: Set<string>;
    catalogResolver: CatalogResolver;
    defaultTag: string;
    dryRun: boolean;
    forceFullResolution: boolean;
    ignoreScripts?: boolean;
    resolvedPkgsById: ResolvedPkgsById;
    resolvePeersFromWorkspaceRoot?: boolean;
    outdatedDependencies: Record<PkgResolutionId, string>;
    childrenByParentId: ChildrenByParentId;
    patchedDependencies?: PatchGroupRecord;
    pendingNodes: PendingNode[];
    wantedLockfile: LockfileObject;
    currentLockfile: LockfileObject;
    injectWorkspacePackages?: boolean;
    linkWorkspacePackagesDepth: number;
    lockfileDir: string;
    storeController: StoreController;
    skipped: Set<PkgResolutionId>;
    dependenciesTree: DependenciesTree<ResolvedPackage>;
    force: boolean;
    preferWorkspacePackages?: boolean;
    readPackageHook?: ReadPackageHook;
    engineStrict: boolean;
    nodeVersion?: string;
    pnpmVersion: string;
    registries: Registries;
    resolutionMode?: 'highest' | 'time-based' | 'lowest-direct';
    virtualStoreDir: string;
    virtualStoreDirMaxLength: number;
    workspacePackages?: WorkspacePackages;
    missingPeersOfChildrenByPkgId: Record<PkgResolutionId, {
        depth: number;
        missingPeersOfChildren: MissingPeersOfChildren;
    }>;
    hoistPeers?: boolean;
    maximumPublishedBy?: Date;
    publishedByExclude?: PackageVersionPolicy;
    trustPolicy?: TrustPolicy;
    trustPolicyExclude?: PackageVersionPolicy;
    trustPolicyIgnoreAfter?: number;
    blockExoticSubdeps?: boolean;
}
export interface MissingPeerInfo {
    range: string;
    optional: boolean;
}
export type MissingPeers = Record<string, MissingPeerInfo>;
export type ResolvedPeers = Record<string, PkgAddress>;
interface MissingPeersOfChildren {
    resolve: (missingPeers: MissingPeers) => void;
    reject: (err: Error) => void;
    get: () => Promise<MissingPeers>;
    resolved?: boolean;
}
export interface PkgAddress extends PkgAddressOrLinkBase {
    depIsLinked: boolean;
    isNew: boolean;
    isLinkedDependency?: false;
    resolvedVia?: string;
    nodeId: NodeId;
    installable: boolean;
    version?: string;
    updated: boolean;
    rootDir: string;
    missingPeers: MissingPeers;
    missingPeersOfChildren?: MissingPeersOfChildren;
    publishedAt?: string;
    saveCatalogName?: string;
}
export type PkgAddressOrLink = PkgAddress | LinkedDependency;
export interface PeerDependency {
    version: string;
    optional?: boolean;
}
export type PeerDependencies = Record<string, PeerDependency>;
export interface ResolvedPackage {
    id: PkgResolutionId;
    isLeaf: boolean;
    resolution: Resolution;
    prod: boolean;
    dev: boolean;
    optional: boolean;
    fetching: () => Promise<PkgRequestFetchResult>;
    filesIndexFile: string;
    name: string;
    version: string;
    peerDependencies: PeerDependencies;
    optionalDependencies: Set<string>;
    hasBin: boolean;
    hasBundledDependencies: boolean;
    patch?: PatchInfo;
    prepare: boolean;
    pkgIdWithPatchHash: PkgIdWithPatchHash;
    requiresBuild?: boolean;
    additionalInfo: {
        deprecated?: string;
        bundleDependencies?: string[] | boolean;
        bundledDependencies?: string[] | boolean;
        engines?: {
            node?: string;
            npm?: string;
        };
        cpu?: string[];
        os?: string[];
        libc?: string[];
    };
}
type ParentPkg = Pick<PkgAddress, 'nodeId' | 'installable' | 'rootDir' | 'optional' | 'pkgId' | 'resolvedVia'>;
export type ParentPkgAliases = Record<string, PkgAddress | true>;
export type UpdateMatchingFunction = (pkgName: string) => boolean;
interface ResolvedDependenciesOptions {
    currentDepth: number;
    parentIds: PkgResolutionId[];
    parentPkg: ParentPkg;
    parentPkgAliases: ParentPkgAliases;
    preferredDependencies?: ResolvedDependencies;
    proceed: boolean;
    publishedBy?: Date;
    pickLowestVersion?: boolean;
    resolvedDependencies?: ResolvedDependencies;
    updateMatching?: UpdateMatchingFunction;
    updateDepth: number;
    prefix: string;
    supportedArchitectures?: SupportedArchitectures;
    updateToLatest?: boolean;
    pinnedVersion?: PinnedVersion;
}
interface PeersResolutionResult {
    missingPeers: MissingPeers;
    resolvedPeers: ResolvedPeers;
}
interface ResolvedRootDependenciesResult {
    pkgAddressesByImporters: PkgAddressOrLink[][];
    time?: Record<string, string>;
}
export declare function resolveRootDependencies(ctx: ResolutionContext, importers: ImporterToResolve[]): Promise<ResolvedRootDependenciesResult>;
interface ResolvedDependenciesResult {
    pkgAddresses: PkgAddressOrLink[];
    resolvingPeers: Promise<PeersResolutionResult>;
}
export type ImporterToResolveOptions = Omit<ResolvedDependenciesOptions, 'parentPkgAliases' | 'publishedBy'>;
export interface ImporterToResolve {
    updatePackageManifest: boolean;
    preferredVersions: PreferredVersions;
    parentPkgAliases: ParentPkgAliases;
    wantedDependencies: Array<WantedDependency & {
        updateDepth?: number;
    }>;
    options: ImporterToResolveOptions;
    pinnedVersion?: PinnedVersion;
}
export interface ResolveDependenciesOfImporterDependencyOpts {
    readonly ctx: ResolutionContext;
    readonly importer: ImporterToResolve;
    readonly pickLowestVersion: boolean;
}
export declare function resolveDependencies(ctx: ResolutionContext, preferredVersions: PreferredVersions, wantedDependencies: Array<WantedDependency & {
    updateDepth?: number;
}>, options: ResolvedDependenciesOptions): Promise<ResolvedDependenciesResult>;
export declare function createNodeIdForLinkedLocalPkg(lockfileDir: string, pkgDir: string): NodeId;
type InfoFromLockfile = {
    pkgId: PkgResolutionId;
    dependencyLockfile?: PackageSnapshot;
    name?: string;
    version?: string;
    resolution?: Resolution;
} & ({
    dependencyLockfile: PackageSnapshot;
    name: string;
    version: string;
    resolution: Resolution;
} | unknown);
export declare function getManifestFromResponse(pkgResponse: PackageResponse, wantedDependency: WantedDependency, currentPkg?: Partial<InfoFromLockfile>): PackageManifest;