import { type CapabilityExecutor } from "./executor.js";
import type { CapabilityPolicy, CapabilityReceipt, DiscoveryQuery, ExecutionOptions } from "./types.js";
import { type CapabilityIndexDocument, type PublicIndexResult } from "./public-index.js";
import { acquireIndexedCapability, type CapabilityPackageInstaller, type InstalledCapabilityPackage } from "./installer.js";
import { type CapabilityTrustAssessment, type CapabilityTrustPolicy } from "./trust.js";
import { type CapabilityLockfile } from "./lockfile.js";
export declare const DEFAULT_CAPABILITY_INDEX_URL = "https://raw.githubusercontent.com/wheresmycoleslaw/capability/main/registry/index.json";
export type CapabilityNetwork = {
    index: CapabilityIndexDocument;
    sources: readonly string[];
};
export type FetchCapabilityNetworkOptions = {
    fetch?: typeof fetch;
    maxDepth?: number;
    maxIndexes?: number;
};
export declare function fetchCapabilityNetwork(roots?: readonly string[], options?: FetchCapabilityNetworkOptions): Promise<CapabilityNetwork>;
export declare function resolveIndexedCapability(index: CapabilityIndexDocument, queryOrId: string): PublicIndexResult;
export type CapabilityHubOptions = {
    indexes?: readonly string[];
    fetch?: typeof fetch;
    installer?: CapabilityPackageInstaller;
    trust?: CapabilityTrustPolicy;
    policy?: CapabilityPolicy;
    executor?: CapabilityExecutor;
    loadCode?: boolean;
    maxDepth?: number;
    maxIndexes?: number;
};
export type HubAcquisition = {
    selection: PublicIndexResult;
    installed: InstalledCapabilityPackage;
    trust: CapabilityTrustAssessment;
    capability: Awaited<ReturnType<typeof acquireIndexedCapability>>["capability"];
};
export type HubExecution = HubAcquisition & {
    receipt: CapabilityReceipt;
};
export declare class CapabilityHub {
    readonly indexes: readonly string[];
    private readonly fetchImpl?;
    private readonly installer;
    private readonly trust;
    private readonly policy;
    private readonly executor;
    private readonly loadCode;
    private readonly maxDepth?;
    private readonly maxIndexes?;
    private network?;
    constructor(options?: CapabilityHubOptions);
    refresh(): Promise<CapabilityNetwork>;
    snapshot(): Promise<CapabilityNetwork>;
    discover(query: DiscoveryQuery | string): Promise<PublicIndexResult[]>;
    resolve(queryOrId: string): Promise<PublicIndexResult>;
    acquire(queryOrId: string): Promise<HubAcquisition>;
    createLock(queryOrId: string): Promise<CapabilityLockfile>;
    run(queryOrId: string, input: unknown, options?: ExecutionOptions): Promise<HubExecution>;
}
export declare function capabilityDoctor(options?: {
    index?: string;
    fetch?: typeof fetch;
}): Promise<{
    indexError?: string | undefined;
    ok: boolean;
    node: string;
    npmAvailable: boolean;
    dockerAvailable: boolean;
    nodePermissionNetworkIsolation: boolean;
    index: string;
    indexReachable: boolean;
}>;
//# sourceMappingURL=ecosystem.d.ts.map