/**
 * Core types for semantic function calling
 */
interface ToolParameter {
    type: 'semantic_color' | 'extracted_content' | 'semantic_category' | 'semantic_number' | 'semantic_boolean';
    semanticCandidates?: string[];
    modifierCandidates?: string[];
    fallback?: any;
    extractionStrategy?: string;
    description?: string;
}
interface Tool {
    name: string;
    description: string;
    contexts: string[];
    intentPatterns: string[];
    parameters: Record<string, ToolParameter>;
    examples?: string[];
}
interface ToolMatch {
    tool: string;
    totalScore: number;
    matches: Array<{
        type: 'intent' | 'context' | 'description';
        text: string;
        score: number;
    }>;
}
interface ExecutionResult {
    success: boolean;
    tool?: string;
    parameters?: Record<string, any>;
    confidence?: number;
    reasoning?: Array<{
        type: string;
        text: string;
        score: number;
    }>;
    mode?: 'standard' | 'first_instinct';
    reason?: string;
}
interface ExecutionOptions {
    gutInstinct?: boolean;
    confidenceThreshold?: number;
    mode?: 'standard' | 'first_instinct';
    verbose?: boolean;
}
interface SemanticFunctionCallerConfig {
    embeddingModel?: string;
    defaultConfidenceThreshold?: number;
    enableCaching?: boolean;
    verbose?: boolean;
}
interface EmbeddingCache {
    [key: string]: Float32Array;
}
interface ParameterValueDatabase {
    colors: {
        basic: string[];
        extended: string[];
        modifiers: string[];
    };
    emotions: string[];
    sizes: string[];
    directions: string[];
    [category: string]: any;
}

/**
 * Main class for semantic function calling
 */
declare class SemanticFunctionCaller {
    private embedder;
    private tools;
    private config;
    private embeddingCache;
    constructor(config?: SemanticFunctionCallerConfig);
    /**
     * Initialize the embedding model
     */
    initialize(): Promise<void>;
    /**
     * Register tools for function calling
     */
    registerTools(tools: Tool[]): void;
    /**
     * Clear all registered tools
     */
    clearTools(): void;
    /**
     * Get embedding with caching
     */
    private getEmbedding;
    /**
     * Find the best tool match using multi-layer semantic analysis
     */
    findToolBySemanticLayers(query: string): Promise<ToolMatch>;
    /**
     * Extract parameters using semantic analysis
     */
    extractParameters(toolName: string, query: string): Promise<Record<string, any>>;
    /**
     * Execute function calling with confidence scoring
     */
    execute(query: string, options?: ExecutionOptions): Promise<ExecutionResult>;
    /**
     * Execute with first instinct mode (no confidence checking)
     */
    executeFirstInstinct(query: string): Promise<ExecutionResult>;
    /**
     * Get cached embedding count (for monitoring)
     */
    getCacheSize(): number;
    /**
     * Clear embedding cache
     */
    clearCache(): void;
}

/**
 * Cosine similarity utility with safety checks
 */
declare function cosineSimilarity(a: number[], b: number[]): number;
/**
 * Batch cosine similarity calculation for efficiency
 */
declare function batchCosineSimilarity(query: number[], vectors: number[][]): number[];

/**
 * Default parameter value database for common semantic types
 */
declare const defaultParameterDatabase: ParameterValueDatabase;
/**
 * Merge custom parameter database with defaults
 */
declare function mergeParameterDatabase(custom: Partial<ParameterValueDatabase>): ParameterValueDatabase;

/**
 * Semantic color extraction using embeddings
 */
declare function extractSemanticColor(query: string, config: ToolParameter, embedder: any): Promise<string>;
/**
 * Semantic category extraction using embeddings
 */
declare function extractSemanticCategory(query: string, config: ToolParameter, embedder: any): Promise<string>;
/**
 * Content isolation using semantic boundaries
 */
declare function extractSemanticContent(query: string, embedder: any): Promise<string>;

/**
 * Homeschool - Teach AI to understand natural language like a patient tutor
 * Advanced embedding-based function calling with semantic understanding,
 * confidence scoring, and natural language parameter extraction
 */

declare const exampleTools: Tool[];
declare const version = "0.1.0";

export { SemanticFunctionCaller, batchCosineSimilarity, cosineSimilarity, defaultParameterDatabase, exampleTools, extractSemanticCategory, extractSemanticColor, extractSemanticContent, mergeParameterDatabase, version };
export type { EmbeddingCache, ExecutionOptions, ExecutionResult, ParameterValueDatabase, SemanticFunctionCallerConfig, Tool, ToolMatch, ToolParameter };