import { ExecutionContext } from "./ExecutionContext";
import { ClassificationTypeConfig } from "./IClassifier";
import { z } from "zod";
import { EventEmitter } from "events";
import { InferClassificationUnion } from "./TypeInference";
export type ToolInput = InferClassificationUnion<readonly ClassificationTypeConfig[]>;
export declare abstract class ToolOutput {
    abstract getContent(): string;
}
export declare class StringOutput extends ToolOutput {
    private content;
    metadata?: Record<string, any> | undefined;
    constructor(content: string, metadata?: Record<string, any> | undefined);
    getContent(): string;
}
export declare class JSONOutput<T> extends ToolOutput {
    private content;
    metadata?: Record<string, any> | undefined;
    constructor(content: T, metadata?: Record<string, any> | undefined);
    getContent(): string;
    getTypedContent(): T;
}
export declare class ToolError extends Error {
    context: Record<string, any>;
    constructor(message: string, context?: Record<string, any>);
}
export declare class ValidationError extends ToolError {
    errors: Array<any>;
    constructor(message: string, errors: Array<any>);
}
export interface ToolOptions {
    cache?: boolean;
    maxRetries?: number;
    retryDelay?: number;
    timeout?: number;
}
export interface RunOptions {
    signal?: AbortSignal;
    context?: Record<string, any>;
}
export interface ToolEvents<TInput = any, TOutput = any> {
    onStart?: (input: TInput, context: ExecutionContext, options: RunOptions) => Promise<void>;
    onSuccess?: (output: TOutput, input: TInput, context: ExecutionContext, options: RunOptions) => Promise<void>;
    onError?: (error: ToolError, input: TInput, context: ExecutionContext, options: RunOptions) => Promise<void>;
    onRetry?: (error: ToolError, attempt: number, input: TInput, context: ExecutionContext, options: RunOptions) => Promise<void>;
}
export declare abstract class Tool<ToolInput, TOutput extends ToolOutput = ToolOutput, TOptions extends ToolOptions = ToolOptions> {
    readonly name: string;
    readonly description: string;
    protected readonly events?: ToolEvents<ToolInput, TOutput> | undefined;
    protected readonly emitter: EventEmitter;
    protected readonly options: TOptions;
    protected context: ExecutionContext;
    constructor(name: string, description: string, options?: TOptions, events?: ToolEvents<ToolInput, TOutput> | undefined);
    setContext(context: ExecutionContext): void;
    abstract schema(): z.ZodSchema<ToolInput>;
    protected abstract execute(input: ToolInput, context: ExecutionContext, options: RunOptions): Promise<TOutput>;
    private validateInput;
    protected withRetry<T>(operation: () => Promise<T>, input: ToolInput, options: RunOptions): Promise<T>;
    run(input: ToolInput, options?: RunOptions): Promise<TOutput>;
    /**
     * Generates an OpenAI-compatible function description for this tool
     */
    getFunctionDescription(): {
        type: 'function';
        function: {
            name: string;
            description: string;
            parameters: {
                type: 'object';
                properties: Record<string, any>;
                required: string[];
            };
        };
    };
    private extractSchemaProperties;
    private extractRequiredFields;
    private zodTypeToJsonSchema;
}
export declare class ToolBuilder<TInput, TOutput extends ToolOutput> extends Tool<TInput, TOutput> {
    private fields;
    constructor(fields: {
        name: string;
        description: string;
        inputSchema: z.ZodSchema<TInput>;
        handler: (input: TInput, context: ExecutionContext, options: RunOptions, runContext?: {
            tool: ToolBuilder<TInput, TOutput>;
        }) => Promise<TOutput>;
        options?: ToolOptions;
        events?: ToolEvents<TInput, TOutput>;
    });
    schema(): z.ZodSchema<TInput>;
    protected execute(input: TInput, context: ExecutionContext, options: RunOptions): Promise<TOutput>;
}