/**
 * Type Signature System
 *
 * Implements structural typing through canonical type signatures.
 * Two types with identical structure map to the same signature,
 * enabling duck typing while maintaining static analysis.
 */
import type { IRType, IRInterfaceDecl, IRClassDecl } from './types.js';
/**
 * Canonical type signature - deterministic representation of a type's structure
 */
export interface TypeSignature {
    /** Unique hash identifying this signature */
    hash: string;
    /** Human-readable signature string */
    canonical: string;
    /** Properties in normalized order */
    properties: PropertySignature[];
    /** Methods in normalized order */
    methods: MethodSignature[];
}
export interface PropertySignature {
    name: string;
    type: string;
    readonly: boolean;
}
export interface MethodSignature {
    name: string;
    params: ParamSignature[];
    returnType: string;
}
export interface ParamSignature {
    name: string;
    type: string;
}
/**
 * Generates canonical type signatures for structural typing
 */
export declare class TypeSignatureGenerator {
    private signatureCache;
    private typeStringCache;
    /**
     * Get or generate signature for an interface
     */
    getInterfaceSignature(iface: IRInterfaceDecl): TypeSignature;
    /**
     * Get or generate signature for a class (public interface only)
     */
    getClassSignature(cls: IRClassDecl): TypeSignature;
    /**
     * Check if two types have compatible signatures (structural typing)
     */
    areCompatible(type1: IRType, type2: IRType): boolean;
    /**
     * Get canonical string representation of a type
     */
    getTypeString(type: IRType): string;
    /**
     * Create signature from properties and methods
     */
    private createSignature;
    /**
     * Simple string hash (FNV-1a)
     */
    private hashString;
    /**
     * Clear all caches
     */
    reset(): void;
}
//# sourceMappingURL=signatures.d.ts.map