import { StructuredTool } from '@langchain/core/tools';
import { z } from 'zod';
import { Logger } from '@hashgraphonline/standards-sdk';
import { FormValidatingToolWrapper } from '../langchain/form-validating-tool-wrapper';
import { ToolFieldConfiguration as FG_ToolFieldConfiguration, FieldGuidanceProvider as FG_FieldGuidanceProvider } from '../forms/field-guidance-registry';

/**
 * Tool capabilities configuration for registry entries
 */
export interface ToolCapabilities {
    supportsFormValidation: boolean;
    requiresWrapper: boolean;
    priority: 'low' | 'medium' | 'high' | 'critical';
    category: 'core' | 'extension' | 'mcp';
}
/**
 * Entity resolution format preferences for tools
 */
export interface EntityResolutionPreferences {
    inscription?: 'hrl' | 'topicId' | 'metadata' | 'any';
    token?: 'tokenId' | 'address' | 'symbol' | 'any';
    nft?: 'serialNumber' | 'metadata' | 'hrl' | 'any';
    account?: 'accountId' | 'alias' | 'evmAddress' | 'any';
}
/**
 * Tool metadata for comprehensive tool information
 */
export interface ToolMetadata {
    name: string;
    version: string;
    category: ToolCapabilities['category'];
    description: string;
    capabilities: ToolCapabilities;
    dependencies: string[];
    schema: unknown;
    entityResolutionPreferences?: EntityResolutionPreferences;
    fieldGuidance?: FG_ToolFieldConfiguration;
    fieldGuidanceProvider?: FG_FieldGuidanceProvider;
}
/**
 * Registry entry containing tool instance and metadata
 */
export interface ToolRegistryEntry {
    tool: StructuredTool;
    metadata: ToolMetadata;
    wrapper?: FormValidatingToolWrapper<z.ZodObject<z.ZodRawShape>> | undefined;
    originalTool: StructuredTool;
    options?: {
        priority?: ToolCapabilities['priority'];
        capability?: string;
        enabled?: boolean;
        namespace?: string;
    };
}
/**
 * Options for tool registration
 */
export interface ToolRegistrationOptions {
    forceWrapper?: boolean;
    skipWrapper?: boolean;
    wrapperConfig?: {
        requireAllFields?: boolean;
        skipFields?: string[];
    };
    metadata?: Partial<ToolMetadata>;
}
/**
 * Query interface for finding tools
 */
export interface ToolQuery {
    name?: string;
    category?: ToolMetadata['category'];
    capabilities?: Partial<ToolCapabilities>;
}
/**
 * Centralized tool registry for managing tool lifecycle
 */
export declare class ToolRegistry {
    private tools;
    private formGenerator;
    private logger;
    constructor(logger?: Logger);
    /**
     * Register a tool with the registry
     */
    registerTool(tool: StructuredTool, options?: ToolRegistrationOptions): void;
    /**
     * Get a tool by name
     */
    getTool(name: string): ToolRegistryEntry | null;
    /**
     * Get tools by capability
     */
    getToolsByCapability(capability: keyof ToolCapabilities, value?: unknown): ToolRegistryEntry[];
    /**
     * Get tools by query
     */
    getToolsByQuery(query: ToolQuery): ToolRegistryEntry[];
    /**
     * Get all registered tools
     */
    getAllTools(): StructuredTool[];
    /**
     * Get all registry entries
     */
    getAllRegistryEntries(): ToolRegistryEntry[];
    /**
     * Get all tool names
     */
    getToolNames(): string[];
    /**
     * Get tools by priority
     */
    getToolsByPriority(priority: ToolCapabilities['priority']): ToolRegistryEntry[];
    /**
     * Get enabled tools (all tools are considered enabled by default)
     */
    getEnabledTools(): ToolRegistryEntry[];
    /**
     * Get tools by namespace/category
     */
    getToolsByNamespace(namespace?: string): ToolRegistryEntry[];
    /**
     * Check if registry has capability
     */
    hasCapability(capability: keyof ToolCapabilities): boolean;
    /**
     * Update tool options (metadata)
     */
    updateToolOptions(name: string, options: Partial<ToolMetadata>): boolean;
    /**
     * Check if a tool is registered
     */
    hasTool(name: string): boolean;
    /**
     * Unregister a tool
     */
    unregisterTool(name: string): boolean;
    /**
     * Clear all tools
     */
    clear(): void;
    /**
     * Analyze tool capabilities
     */
    private analyzeToolCapabilities;
    /**
     * Check if tool has render configuration
     */
    private hasRenderConfig;
    /**
     * Determine if tool should be wrapped
     */
    private shouldWrapTool;
    /**
     * Check if schema is ZodObject-like
     */
    private isZodObjectLike;
    /**
     * Get statistics about the registry
     */
    getStatistics(): {
        totalTools: number;
        wrappedTools: number;
        unwrappedTools: number;
        categoryCounts: Record<ToolCapabilities['category'], number>;
        priorityCounts: Record<ToolCapabilities['priority'], number>;
    };
}