import { Marker, Markers } from "../markers";
import { UUID } from "../uuid";
export declare const NodeResolutionResultKind: "org.openrewrite.javascript.marker.NodeResolutionResult";
export declare const DependencyKind: "org.openrewrite.javascript.marker.NodeResolutionResult$Dependency";
export declare const ResolvedDependencyKind: "org.openrewrite.javascript.marker.NodeResolutionResult$ResolvedDependency";
/**
 * Parsed package.json content structure.
 */
export interface PackageJsonContent {
    readonly name?: string;
    readonly version?: string;
    readonly description?: string;
    readonly dependencies?: Record<string, string>;
    readonly devDependencies?: Record<string, string>;
    readonly peerDependencies?: Record<string, string>;
    readonly optionalDependencies?: Record<string, string>;
    readonly bundledDependencies?: string[];
    readonly bundleDependencies?: string[];
    readonly engines?: Record<string, string>;
}
/**
 * Package entry in a package-lock.json packages map.
 */
export interface PackageLockEntry {
    readonly version?: string;
    readonly resolved?: string;
    readonly integrity?: string;
    readonly license?: string | string[] | {
        type?: string;
        url?: string;
    };
    readonly dependencies?: Record<string, string>;
    readonly devDependencies?: Record<string, string>;
    readonly peerDependencies?: Record<string, string>;
    readonly optionalDependencies?: Record<string, string>;
    readonly engines?: Record<string, string> | string[];
}
/**
 * Parsed package-lock.json content structure (npm lockfile v3 format).
 */
export interface PackageLockContent {
    readonly name?: string;
    readonly version?: string;
    readonly lockfileVersion?: number;
    readonly packages?: Record<string, PackageLockEntry>;
}
/**
 * Represents the package manager used by a Node.js project.
 */
export declare const enum PackageManager {
    Npm = "Npm",
    YarnClassic = "YarnClassic",
    YarnBerry = "YarnBerry",
    Pnpm = "Pnpm",
    Bun = "Bun"
}
/**
 * Represents the scope/source of an npmrc configuration.
 * Listed from lowest to highest priority.
 */
export declare const enum NpmrcScope {
    Global = "Global",// $PREFIX/etc/npmrc
    User = "User",// $HOME/.npmrc
    Project = "Project"
}
/**
 * Represents a dependency scope in package.json that uses object structure {name: version}.
 * Note: `bundledDependencies` is excluded because it's a string[] of package names, not a version map.
 */
export type DependencyScope = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
/**
 * All dependency scopes in package.json that use object structure {name: version}.
 */
export declare const allDependencyScopes: readonly DependencyScope[];
export declare const NpmrcKind: "org.openrewrite.javascript.marker.NodeResolutionResult$Npmrc";
/**
 * Represents npm configuration from a specific scope.
 * Multiple Npmrc objects can be collected (one per scope) to allow
 * recipes to merge configurations or modify specific scopes.
 */
export interface Npmrc {
    readonly kind: typeof NpmrcKind;
    readonly scope: NpmrcScope;
    readonly properties: Record<string, string>;
}
/**
 * Represents a dependency request as declared in package.json.
 * This is what a package asks for (name + version constraint).
 *
 * When the same name+versionConstraint appears multiple times, the same
 * Dependency instance is reused. This enables reference deduplication
 * during RPC serialization via asRef().
 */
export interface Dependency {
    readonly kind: typeof DependencyKind;
    readonly name: string;
    readonly versionConstraint: string;
    readonly resolved?: ResolvedDependency;
}
/**
 * Represents a resolved dependency from package-lock.json.
 * This is what was actually installed (name + resolved version + its own dependencies).
 *
 * Each ResolvedDependency's dependency arrays contain Dependency objects (requests),
 * which can be looked up in NodeResolutionResult.resolvedDependencies to find their resolved versions.
 */
export interface ResolvedDependency {
    readonly kind: typeof ResolvedDependencyKind;
    readonly name: string;
    readonly version: string;
    readonly dependencies?: Dependency[];
    readonly devDependencies?: Dependency[];
    readonly peerDependencies?: Dependency[];
    readonly optionalDependencies?: Dependency[];
    readonly engines?: Record<string, string>;
    readonly license?: string;
}
/**
 * Contains metadata about a Node.js project, parsed from package.json and package-lock.json.
 * Attached as a marker to JS.CompilationUnit to provide dependency context for recipes.
 *
 * Similar to MavenResolutionResult marker, this allows recipes to:
 * - Query project dependencies
 * - Check if specific packages are in use
 * - Modify dependencies programmatically
 * - Understand the project structure
 *
 * The model separates requests (Dependency) from resolutions (ResolvedDependency):
 * - The dependency arrays contain Dependency objects (what was requested)
 * - The resolvedDependencies list contains what was actually installed
 */
export interface NodeResolutionResult extends Marker {
    readonly kind: typeof NodeResolutionResultKind;
    readonly id: UUID;
    readonly name?: string;
    readonly version?: string;
    readonly description?: string;
    readonly path: string;
    readonly workspacePackagePaths?: string[];
    readonly dependencies: Dependency[];
    readonly devDependencies: Dependency[];
    readonly peerDependencies: Dependency[];
    readonly optionalDependencies: Dependency[];
    readonly bundledDependencies: Dependency[];
    readonly resolvedDependencies: ResolvedDependency[];
    readonly packageManager?: PackageManager;
    readonly engines?: Record<string, string>;
    readonly npmrcConfigs?: Npmrc[];
}
/**
 * Creates a NodeResolutionResult marker from a package.json file.
 * Should be called during parsing to attach to JS.CompilationUnit.
 *
 * All Dependency instances are wrapped with asRef() to enable
 * reference deduplication during RPC serialization.
 *
 * @param path Path to the package.json file
 * @param packageJsonContent Parsed package.json content
 * @param packageLockContent Optional parsed package-lock.json content for resolution info
 * @param workspacePackagePaths Optional resolved paths to workspace package.json files (only for workspace root)
 * @param packageManager Optional package manager that was detected from lock file
 * @param npmrcConfigs Optional npm configuration from various scopes
 */
export declare function createNodeResolutionResultMarker(path: string, packageJsonContent: PackageJsonContent, packageLockContent?: PackageLockContent, workspacePackagePaths?: string[], packageManager?: PackageManager, npmrcConfigs?: Npmrc[]): NodeResolutionResult;
/**
 * Helper function to find a NodeResolutionResult marker on a compilation unit.
 */
export declare function findNodeResolutionResult(cu: {
    markers: Markers;
}): NodeResolutionResult | undefined;
/**
 * Serializes Npmrc configurations to .npmrc file format.
 *
 * Merges properties from multiple scopes in priority order (Global -> User -> Project),
 * so higher-priority scopes override lower-priority ones.
 *
 * @param configs Array of Npmrc configurations from the marker
 * @param scopes Which scopes to include (default: ['Project'])
 * @returns Serialized .npmrc content, or undefined if no matching configs
 */
export declare function serializeNpmrcConfigs(configs: Npmrc[] | undefined, scopes?: NpmrcScope[]): string | undefined;
/**
 * Reads .npmrc configurations from all scope levels.
 * Returns an array of Npmrc objects, one for each scope that has configuration.
 *
 * Scopes (from lowest to highest priority):
 * - Global: $PREFIX/etc/npmrc (npm's installation directory)
 * - User: $HOME/.npmrc (user's home directory)
 * - Project: .npmrc in project root (sibling of package.json)
 * - Env: npm_config_* environment variables
 *
 * @param projectDir The project directory containing package.json
 * @returns Promise resolving to array of Npmrc objects for each scope with configuration
 */
export declare function readNpmrcConfigs(projectDir: string): Promise<Npmrc[]>;
/**
 * Helper functions for querying dependencies
 */
export declare namespace NodeResolutionResultQueries {
    /**
     * Get all dependency requests from all scopes.
     */
    function getAllDependencies(project: NodeResolutionResult): Dependency[];
    /**
     * Check if project has a specific dependency request, optionally filtered by scope.
     */
    function hasDependency(project: NodeResolutionResult, packageName: string, scope?: 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies' | 'bundledDependencies'): boolean;
    /**
     * Find a specific dependency request by name across all scopes.
     */
    function findDependency(project: NodeResolutionResult, packageName: string): Dependency | undefined;
    /**
     * Get all dependency requests matching a predicate.
     */
    function findDependencies(project: NodeResolutionResult, predicate: (dep: Dependency) => boolean): Dependency[];
    /**
     * Get all resolved dependencies with a specific name (handles multiple versions).
     * Returns an empty array if no versions are found.
     *
     * For navigation, prefer using the Dependency.resolved property:
     * @example
     * const express = project.dependencies.find(d => d.name === 'express')?.resolved;
     * const accepts = express?.dependencies?.find(d => d.name === 'accepts')?.resolved;
     */
    function getAllResolvedVersions(project: NodeResolutionResult, packageName: string): ResolvedDependency[];
}
//# sourceMappingURL=node-resolution-result.d.ts.map