import type { CompletionBudget } from '../../complete/backtrack.js';
import type { OnUnevaluable } from '../../complete/constraints.js';
import { type EdgeTriple, type Graph, type NodeId, type OverrideConstraint } from './graph.js';
import type { GraphFrontier } from './modify.js';
import type { GraphOperationResult, OperationOptions } from './operation.js';
import type { PackumentVersion, RegistryAdapter } from './registry.js';
export type Awaitable<T> = T | Promise<T>;
export type ConditionVerdict = Readonly<{
    ok: true;
}> | Readonly<{
    ok: false;
    reason?: string;
}> | Readonly<{
    ok: 'unevaluable';
    reason?: string;
}>;
export interface ConditionContext {
    readonly name: string;
    readonly version: string;
    readonly candidate: PackumentVersion;
    manifest(): Promise<PackumentVersion | undefined>;
    readonly registry: RegistryAdapter;
}
export interface Condition {
    readonly kind: string;
    readonly cost?: number;
    evaluate(context: ConditionContext): Awaitable<ConditionVerdict>;
}
export interface RejectedCandidate {
    readonly name: string;
    readonly version: string;
    readonly condition: string;
    readonly reason?: string;
}
export interface SelectConstrainedOptions {
    readonly registry: RegistryAdapter;
    readonly conditions: readonly Condition[];
    readonly onUnevaluable?: OnUnevaluable;
}
export interface SelectConstrainedResult {
    readonly selected?: PackumentVersion;
    readonly rejected: readonly RejectedCandidate[];
}
export declare const engines: (required: Readonly<Record<string, string>>, options?: Readonly<{
    mode?: 'lenient' | 'strict';
}>) => Condition;
export declare const license: (options: Readonly<{
    allow?: readonly string[];
    deny?: readonly string[];
}>) => Condition;
export declare const selectConstrained: (name: string, range: string, options: SelectConstrainedOptions) => Promise<SelectConstrainedResult>;
export interface CompleteOptions extends OperationOptions {
    readonly seed?: GraphFrontier;
    readonly pruneOrphans?: boolean;
    readonly resolution?: 'highest' | 'prefer-existing';
    readonly overrides?: readonly OverrideConstraint[];
    readonly constraints?: readonly Condition[];
    readonly onUnevaluable?: OnUnevaluable;
    readonly budget?: CompletionBudget;
}
export interface CompleteResult extends GraphOperationResult {
    readonly added: readonly NodeId[];
    readonly wired: readonly EdgeTriple[];
    readonly removed: readonly NodeId[];
}
export declare function complete(graph: Graph, options: CompleteOptions): Promise<CompleteResult>;
export type { CompletionBudget, OnUnevaluable };