import { Reference } from "./types";
export type CapabilityAuditStatus = "start" | "success" | "error" | "rejected" | "timeout";
export type CapabilityAuditEvent<TContext = unknown> = {
    context: TContext;
    durationMs?: number;
    error?: Error;
    input: unknown;
    output?: unknown;
    status: CapabilityAuditStatus;
    tool: string;
};
export type CapabilityAuditBufferOptions = {
    /**
     * Maximum audit events retained in memory. Extra events are dropped and
     * reported through `dropped` / `truncated` and `receiptOptions()`.
     */
    maxEvents?: number;
};
export type CapabilityAuditBufferSnapshot<TContext = unknown> = {
    dropped: number;
    events: CapabilityAuditEvent<TContext>[];
    truncated: boolean;
};
export type CapabilityAuditBuffer<TContext = unknown> = {
    readonly dropped: number;
    readonly events: readonly CapabilityAuditEvent<TContext>[];
    readonly truncated: boolean;
    clear: () => void;
    onAudit: (event: CapabilityAuditEvent<TContext>) => void;
    receiptOptions: () => {
        capabilityEvents: readonly CapabilityAuditEvent<TContext>[];
        capabilityEventsDropped: () => number;
        capabilityEventsTruncated: () => boolean;
    };
    snapshot: () => CapabilityAuditBufferSnapshot<TContext>;
};
export type CapabilityValidator<T> = (value: unknown) => T;
export type CapabilityAuditRedactor<TContext = unknown> = (value: unknown, context: TContext, tool: string) => unknown;
export type CapabilityRisk = "read-only" | "read-write" | "network" | "filesystem" | "exec" | "unknown";
export type CapabilitySchemaDescriptor = string | {
    description?: string;
    name?: string;
};
export type CapabilityManifestEntry = {
    concurrency?: number;
    description?: string;
    hasInputValidator: boolean;
    hasOutputValidator: boolean;
    input?: CapabilitySchemaDescriptor;
    maxOutputBytes?: number;
    name: string;
    output?: CapabilitySchemaDescriptor;
    redactsInput?: boolean;
    redactsOutput?: boolean;
    risk: CapabilityRisk;
    schemaVersion: 1;
    timeoutMs?: number;
};
export type CapabilityTool<TInput = unknown, TOutput = unknown, TContext = unknown> = {
    concurrency?: number;
    description?: string;
    handler: (input: TInput, context: TContext) => TOutput | Promise<TOutput>;
    input?: CapabilitySchemaDescriptor;
    maxOutputBytes?: number;
    output?: CapabilitySchemaDescriptor;
    redactAuditInput?: CapabilityAuditRedactor<TContext>;
    redactAuditOutput?: CapabilityAuditRedactor<TContext>;
    risk?: CapabilityRisk;
    validateInput?: CapabilityValidator<TInput>;
    validateOutput?: CapabilityValidator<TOutput>;
    timeoutMs?: number;
};
export type InferCapabilityInput<TTool> = TTool extends {
    validateInput: CapabilityValidator<infer TInput>;
} ? TInput : TTool extends CapabilityTool<infer TInput, any, any> ? TInput : unknown;
export type InferCapabilityOutput<TTool> = TTool extends {
    validateOutput: CapabilityValidator<infer TOutput>;
} ? TOutput : TTool extends CapabilityTool<any, infer TOutput, any> ? TOutput : unknown;
export type InferCapabilityContext<TTool> = TTool extends CapabilityTool<any, any, infer TContext> ? TContext : unknown;
type AnyCapabilityTool<TContext = unknown> = CapabilityTool<any, any, TContext>;
export type CapabilityBrokerCall<TTools extends Record<string, AnyCapabilityTool<any>>> = {
    <TToolName extends Extract<keyof TTools, string>>(tool: TToolName, input: InferCapabilityInput<TTools[TToolName]>): Promise<InferCapabilityOutput<TTools[TToolName]>>;
    (tool: string, input?: unknown): Promise<unknown>;
};
export type CapabilityBrokerFor<TTools extends Record<string, AnyCapabilityTool<any>>> = {
    call: CapabilityBrokerCall<TTools>;
    manifest: () => CapabilityManifestEntry[];
    reference: Reference<(tool: unknown, input?: unknown) => Promise<unknown>>;
};
type ValidatedCapabilityTool<TInput, TOutput, TContext> = Omit<CapabilityTool<TInput, TOutput, TContext>, "handler" | "validateInput"> & {
    handler: (input: TInput, context: TContext) => TOutput | Promise<TOutput>;
    validateInput: CapabilityValidator<TInput>;
};
export declare function defineCapabilityTool<TInput, TOutput, TContext = unknown>(tool: ValidatedCapabilityTool<TInput, TOutput, TContext>): CapabilityTool<TInput, TOutput, TContext>;
export declare function defineCapabilityTool<TInput = unknown, TOutput = unknown, TContext = unknown>(tool: CapabilityTool<TInput, TOutput, TContext>): CapabilityTool<TInput, TOutput, TContext>;
export type CapabilityBrokerOptions<TContext = unknown> = {
    context: TContext;
    defaultConcurrency?: number;
    defaultMaxOutputBytes?: number;
    defaultTimeoutMs?: number;
    onAudit?: (event: CapabilityAuditEvent<TContext>) => void;
    redactAuditInput?: CapabilityAuditRedactor<TContext>;
    redactAuditOutput?: CapabilityAuditRedactor<TContext>;
};
export type CapabilityBroker = {
    call: (tool: string, input?: unknown) => Promise<unknown>;
    manifest: () => CapabilityManifestEntry[];
    reference: Reference<(tool: unknown, input?: unknown) => Promise<unknown>>;
};
export declare class CapabilityError extends Error {
    readonly code: string;
    readonly tool: string;
    constructor(tool: string, code: string, message: string);
}
export declare const createCapabilityAuditBuffer: <TContext = unknown>(options?: CapabilityAuditBufferOptions) => CapabilityAuditBuffer<TContext>;
export declare const createCapabilityBroker: <TTools extends Record<string, AnyCapabilityTool<any>>, TContext = InferCapabilityContext<TTools[keyof TTools]>>(tools: TTools, options: CapabilityBrokerOptions<TContext>) => CapabilityBrokerFor<TTools>;
export {};