import { FlagDependency, FlagId, VariantId, DependencyType, JsonValue } from './types';
/**
 * Result of dependency resolution.
 */
export interface DependencyResolutionResult {
    /** Whether all dependencies are satisfied */
    readonly satisfied: boolean;
    /** Unsatisfied dependencies */
    readonly unsatisfied: readonly UnsatisfiedDependency[];
    /** Order in which flags should be evaluated */
    readonly evaluationOrder: readonly FlagId[];
    /** Detected circular dependencies */
    readonly circularDependencies: readonly FlagId[][];
    /** Implied flags to enable */
    readonly implied: readonly FlagId[];
    /** Conflicting flags that are currently enabled */
    readonly conflicts: readonly FlagId[];
}
/**
 * Details of an unsatisfied dependency.
 */
export interface UnsatisfiedDependency {
    /** The flag with the unsatisfied dependency */
    readonly sourceFlag: FlagId;
    /** The target flag that failed */
    readonly targetFlag: FlagId;
    /** Type of dependency */
    readonly type: DependencyType;
    /** Reason for failure */
    readonly reason: string;
    /** Required variant (if applicable) */
    readonly requiredVariant?: VariantId;
    /** Actual variant (if applicable) */
    readonly actualVariant?: VariantId;
}
/**
 * Function type for evaluating a flag's state.
 */
export type FlagEvaluator = (flagId: FlagId) => {
    enabled: boolean;
    variantId?: VariantId;
    value?: JsonValue;
};
/**
 * Resolves and validates flag dependencies.
 */
export declare class DependencyResolver {
    private graph;
    private dependencies;
    /**
     * Build the dependency graph from a list of dependencies.
     */
    buildGraph(dependencies: readonly FlagDependency[]): void;
    /**
     * Add a dependency to the graph.
     */
    addDependency(dependency: FlagDependency): void;
    /**
     * Remove a dependency from the graph.
     */
    removeDependency(sourceFlag: FlagId, targetFlag: FlagId): void;
    /**
     * Resolve all dependencies for a flag.
     */
    resolveDependencies(flagId: FlagId, evaluator: FlagEvaluator): DependencyResolutionResult;
    /**
     * Detect circular dependencies in the graph.
     */
    detectCircularDependencies(): FlagId[][];
    /**
     * Get the evaluation order for a flag (topological sort).
     */
    getEvaluationOrder(flagId: FlagId): FlagId[];
    /**
     * Get all flags that depend on a given flag.
     */
    getDependents(flagId: FlagId): FlagId[];
    /**
     * Get all dependencies of a flag.
     */
    getDependencies(flagId: FlagId): FlagDependency[];
    /**
     * Get all flags in the graph.
     */
    getAllFlags(): FlagId[];
    /**
     * Check if a flag has any dependencies.
     */
    hasDependencies(flagId: FlagId): boolean;
    /**
     * Check if a flag has any dependents.
     */
    hasDependents(flagId: FlagId): boolean;
    /**
     * Export the graph for visualization.
     */
    exportGraph(): {
        nodes: Array<{
            id: FlagId;
            dependencyCount: number;
            dependentCount: number;
        }>;
        edges: Array<{
            source: FlagId;
            target: FlagId;
            type: DependencyType;
        }>;
    };
    /**
     * Clear the dependency graph.
     */
    clear(): void;
    private ensureNode;
    private checkDependency;
}
/**
 * Fluent builder for creating flag dependencies.
 */
export declare class DependencyBuilder {
    private readonly sourceFlag;
    private dependencies;
    constructor(sourceFlag: FlagId);
    /**
     * Add a "requires" dependency.
     */
    requires(targetFlag: FlagId, options?: {
        variant?: VariantId;
        description?: string;
    }): this;
    /**
     * Add a "conflicts" dependency.
     */
    conflicts(targetFlag: FlagId, description?: string): this;
    /**
     * Add an "implies" dependency.
     */
    implies(targetFlag: FlagId, description?: string): this;
    /**
     * Add a "supersedes" dependency.
     */
    supersedes(targetFlag: FlagId, description?: string): this;
    /**
     * Build the dependencies.
     */
    build(): FlagDependency[];
}
/**
 * Create a dependency builder for a flag.
 */
export declare function createDependencies(sourceFlag: FlagId): DependencyBuilder;
/**
 * Validate a set of dependencies.
 */
export declare function validateDependencies(dependencies: readonly FlagDependency[]): {
    valid: boolean;
    errors: string[];
    warnings: string[];
};
/**
 * Generate a DOT representation of the dependency graph for visualization.
 */
export declare function generateDependencyDOT(dependencies: readonly FlagDependency[]): string;
/**
 * Get the singleton dependency resolver instance.
 */
export declare function getDependencyResolver(): DependencyResolver;
/**
 * Reset the singleton instance.
 */
export declare function resetDependencyResolver(): void;