import { discoverSoftwareWorld } from "./external-discovery.js";
import { type RepositoryCapabilityCandidate, type RepositoryMiningReport } from "./repository-mine.js";
import type { CapabilityEffect, CapabilityReceipt } from "./types.js";
export declare const CAPABILITY_FORGE_VERSION: "0.1";
export declare const CAPABILITY_FORGE_RUNTIME_VERSION: "^0.9.0";
export type ForgeBindingKind = "npm-cli" | "npm-export";
export type ForgeSourceBinding = "verified-git-head" | "unverified-source-artifact-link";
export type ForgeDescriptor = {
    forgeVersion: typeof CAPABILITY_FORGE_VERSION;
    createdAt: string;
    repository: {
        fullName: string;
        url: string;
        commit: string;
    };
    evidence: {
        candidateId: string;
        sourcePath: string;
        line?: number;
        symbol?: string;
        confidence: RepositoryCapabilityCandidate["confidence"];
        evidenceHash: string;
    };
    artifact: {
        registry: "npm";
        package: string;
        version: string;
        integrity?: string;
        gitHead?: string;
        sourceBinding: ForgeSourceBinding;
    };
    binding: {
        kind: ForgeBindingKind;
        capabilityId: string;
        exportName?: string;
        bin?: string;
    };
    authority: {
        complete: false;
        inferredEffects: readonly CapabilityEffect[];
        note: string;
    };
};
export type ForgeGitHubOptions = {
    query?: string;
    ref?: string;
    candidateId?: string;
    symbol?: string;
    packageVersion?: string;
    capabilityId?: string;
    directory?: string;
    maxFiles?: number;
    maxCandidates?: number;
    allowUnverifiedSource?: boolean;
    force?: boolean;
    fetch?: typeof fetch;
    githubToken?: string;
};
export type ForgedAbility = {
    descriptor: ForgeDescriptor;
    project: {
        directory: string;
        packageName: string;
        capabilityId: string;
        files: readonly string[];
    };
    candidate: RepositoryCapabilityCandidate;
    mining: {
        commit: string;
        coverage: RepositoryMiningReport["coverage"];
        hazards: readonly string[];
    };
};
export type SolveIntentOptions = {
    indexes?: readonly string[];
    limit?: number;
    input?: unknown;
    approved?: boolean;
    externalOnly?: boolean;
    directory?: string;
    maxForgeAttempts?: number;
    allowUnverifiedSource?: boolean;
    fetch?: typeof fetch;
    githubToken?: string;
};
export type SolveIntentResult = {
    query: string;
    route: "native" | "forged" | "unresolved";
    discovery: Awaited<ReturnType<typeof discoverSoftwareWorld>>;
    native?: {
        id: string;
        package: string;
        intentFit: ReturnType<typeof assessNativeIntentFit>;
        receipt?: CapabilityReceipt;
    };
    forged?: ForgedAbility & {
        receipt?: CapabilityReceipt;
    };
    attempts: readonly {
        repository: string;
        ok: boolean;
        reason?: string;
    }[];
};
export declare function assessNativeIntentFit(query: string, candidate: {
    id: string;
    name: string;
    description: string;
}): {
    accepted: boolean;
    coverage: number;
    matched: string[];
    missing: string[];
};
export declare function forgeGitHubAbility(locator: string, options?: ForgeGitHubOptions): Promise<ForgedAbility>;
export declare function activateForgedAbility(forged: ForgedAbility, input: unknown, options?: {
    approved?: boolean;
    dockerCommand?: string;
}): Promise<CapabilityReceipt>;
export declare function solveSoftwareIntent(query: string, options?: SolveIntentOptions): Promise<SolveIntentResult>;
//# sourceMappingURL=forge.d.ts.map