/**
 * FUNCTION CALLING / TOOL USE
 * OpenAI-style function calling, tool definitions, parameter validation
 */
export declare enum ParameterType {
    STRING = "string",
    NUMBER = "number",
    INTEGER = "integer",
    BOOLEAN = "boolean",
    ARRAY = "array",
    OBJECT = "object",
    NULL = "null"
}
export interface FunctionParameter {
    type: ParameterType | ParameterType[];
    description?: string;
    enum?: unknown[];
    items?: FunctionParameter;
    properties?: Record<string, FunctionParameter>;
    required?: string[];
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    default?: unknown;
}
export interface FunctionDefinition {
    name: string;
    description: string;
    parameters: FunctionParameter;
}
export interface ToolDefinition {
    type: 'function';
    function: FunctionDefinition;
}
export interface FunctionCall {
    name: string;
    arguments: string;
}
export interface ToolCall {
    id: string;
    type: 'function';
    function: FunctionCall;
}
export interface FunctionResult {
    call_id: string;
    name: string;
    result: unknown;
    error?: string;
    duration_ms: number;
}
export declare class FunctionRegistry {
    private functions;
    /**
     * Register function
     */
    register(definition: FunctionDefinition, handler: (args: Record<string, unknown>) => Promise<unknown>): void;
    /**
     * Unregister function
     */
    unregister(name: string): boolean;
    /**
     * Get function definition
     */
    getDefinition(name: string): FunctionDefinition | null;
    /**
     * Get all definitions
     */
    getDefinitions(): FunctionDefinition[];
    /**
     * Get as tool definitions
     */
    getToolDefinitions(): ToolDefinition[];
    /**
     * Execute function
     */
    execute(call: ToolCall): Promise<FunctionResult>;
    /**
     * Execute multiple function calls
     */
    executeAll(calls: ToolCall[]): Promise<FunctionResult[]>;
    /**
     * Check if function exists
     */
    has(name: string): boolean;
    /**
     * Validate arguments
     */
    private validate;
    private getType;
}
export declare class FunctionBuilder {
    private definition;
    /**
     * Set function name
     */
    name(name: string): this;
    /**
     * Set function description
     */
    description(description: string): this;
    /**
     * Add parameter
     */
    addParameter(name: string, schema: FunctionParameter, required?: boolean): this;
    /**
     * Add string parameter
     */
    addString(name: string, description: string, required?: boolean, options?: {
        enum?: string[];
        pattern?: string;
        minLength?: number;
        maxLength?: number;
    }): this;
    /**
     * Add number parameter
     */
    addNumber(name: string, description: string, required?: boolean, options?: {
        minimum?: number;
        maximum?: number;
    }): this;
    /**
     * Add boolean parameter
     */
    addBoolean(name: string, description: string, required?: boolean): this;
    /**
     * Add array parameter
     */
    addArray(name: string, description: string, items: FunctionParameter, required?: boolean): this;
    /**
     * Add object parameter
     */
    addObject(name: string, description: string, properties: Record<string, FunctionParameter>, required_props?: string[]): this;
    /**
     * Build definition
     */
    build(): FunctionDefinition;
}
export declare class ToolCallParser {
    /**
     * Parse tool calls from model response
     */
    parse(response: unknown): ToolCall[];
    /**
     * Format results for model
     */
    formatResults(results: FunctionResult[]): unknown[];
    private generateId;
}
//# sourceMappingURL=function-registry.d.ts.map