/**
 * Genera embedding de una imagen en un solo paso
 *
 * @param {Float32Array|Uint8Array} imageData
 * @param {number} width
 * @param {number} height
 * @param {string} mode - 'micro' | 'compact' | 'standard' | 'full'
 * @returns {ImageEmbedding}
 */
export function embedImage(imageData: Float32Array | Uint8Array, width: number, height: number, mode?: string): ImageEmbedding;
/**
 * Compara dos imágenes directamente
 *
 * @param {Float32Array} img1Data
 * @param {number} img1Width
 * @param {number} img1Height
 * @param {Float32Array} img2Data
 * @param {number} img2Width
 * @param {number} img2Height
 * @param {string} mode
 * @returns {number} Similitud 0-1
 */
export function compareImages(img1Data: Float32Array, img1Width: number, img1Height: number, img2Data: Float32Array, img2Width: number, img2Height: number, mode?: string): number;
/**
 * Detecta si dos imágenes son duplicados (o casi-duplicados)
 *
 * @param {ImageEmbedding} emb1
 * @param {ImageEmbedding} emb2
 * @param {number} threshold - Umbral de similitud (default: 0.85)
 * @returns {boolean}
 */
export function isDuplicate(emb1: ImageEmbedding, emb2: ImageEmbedding, threshold?: number): boolean;
/**
 * Generador de Image Embeddings
 *
 * @example
 * const embedder = new ImageEmbedder('standard');
 *
 * // Generar embedding de una imagen
 * const embedding = embedder.embed(imageData, width, height);
 *
 * // Comparar dos imágenes
 * const similarity = embedder.compare(embedding1, embedding2);
 *
 * // Buscar en base de datos
 * const results = embedder.search(queryEmbedding, database, topK=10);
 */
export class ImageEmbedder {
    constructor(mode?: string);
    config: any;
    basis: any;
    mode: string;
    /**
     * Genera un embedding de una imagen en escala de grises
     *
     * @param {Float32Array|Uint8Array} imageData - Datos de imagen (grayscale)
     * @param {number} width - Ancho de la imagen
     * @param {number} height - Alto de la imagen
     * @returns {ImageEmbedding} Objeto embedding
     */
    embed(imageData: Float32Array | Uint8Array, width: number, height: number): ImageEmbedding;
    /**
     * Compara dos embeddings y retorna similitud [0, 1]
     *
     * Usa una métrica ajustada donde:
     * - Idénticos = 1.0
     * - Aleatorios (50% hamming) = 0.0
     * - Completamente opuestos = -1.0 (pero clampeamos a 0)
     *
     * @param {ImageEmbedding} emb1
     * @param {ImageEmbedding} emb2
     * @returns {number} Similitud entre 0 (diferente/random) y 1 (idéntico)
     */
    compare(emb1: ImageEmbedding, emb2: ImageEmbedding): number;
    /**
     * Busca los embeddings más similares en una base de datos
     *
     * @param {ImageEmbedding} query - Embedding a buscar
     * @param {ImageEmbedding[]} database - Array de embeddings
     * @param {number} topK - Número de resultados a retornar
     * @returns {Array<{index: number, similarity: number}>} Resultados ordenados
     */
    search(query: ImageEmbedding, database: ImageEmbedding[], topK?: number): Array<{
        index: number;
        similarity: number;
    }>;
    /**
     * Agrupa embeddings por similitud (clustering)
     *
     * @param {ImageEmbedding[]} embeddings
     * @param {number} threshold - Umbral de similitud para agrupar (0-1)
     * @returns {number[]} Array de cluster IDs para cada embedding
     */
    cluster(embeddings: ImageEmbedding[], threshold?: number): number[];
    /**
     * Comprime el hypervector HDC al tamaño de salida deseado
     */
    _compressToSize(hv: any, targetBits: any): Uint32Array<any>;
    /**
     * Weighted Bundle: Combina hypervectors con pesos
     * Features con mayor score contribuyen más al resultado final
     */
    _weightedBundle(hvs: any, weights: any): Uint32Array<ArrayBuffer>;
}
/**
 * Representa un embedding de imagen
 */
export class ImageEmbedding {
    /**
     * Crea un embedding desde bytes
     * @param {Uint8Array} bytes
     * @returns {ImageEmbedding}
     */
    static fromBytes(bytes: Uint8Array): ImageEmbedding;
    /**
     * Crea un embedding desde Base64
     * @param {string} base64
     * @returns {ImageEmbedding}
     */
    static fromBase64(base64: string): ImageEmbedding;
    constructor(vector: any, metadata?: {});
    vector: any;
    metadata: {};
    /**
     * Serializa el embedding a bytes para storage
     * @returns {Uint8Array}
     */
    toBytes(): Uint8Array;
    /**
     * Serializa a Base64 para transmisión
     * @returns {string}
     */
    toBase64(): string;
    /**
     * Serializa a hex string
     * @returns {string}
     */
    toHex(): string;
    /**
     * Convierte el vector binario a un array de floats (0.0 o 1.0)
     * Útil para compatibilidad con bases de datos vectoriales que esperan arrays de números (como LLMs)
     *
     * @returns {Float32Array}
     */
    toFloatArray(): Float32Array;
    /**
     * Número de bits del embedding
     */
    get bits(): number;
    /**
     * Número de bytes del embedding
     */
    get bytes(): number;
}
export namespace EMBEDDING_CONFIGS {
    namespace micro {
        let outputBits: number;
        let maxFeatures: number;
        let pyramidOctaves: number;
    }
    namespace compact {
        let outputBits_1: number;
        export { outputBits_1 as outputBits };
        let maxFeatures_1: number;
        export { maxFeatures_1 as maxFeatures };
        let pyramidOctaves_1: number;
        export { pyramidOctaves_1 as pyramidOctaves };
    }
    namespace standard {
        let outputBits_2: number;
        export { outputBits_2 as outputBits };
        let maxFeatures_2: number;
        export { maxFeatures_2 as maxFeatures };
        let pyramidOctaves_2: number;
        export { pyramidOctaves_2 as pyramidOctaves };
    }
    namespace full {
        let outputBits_3: number;
        export { outputBits_3 as outputBits };
        let maxFeatures_3: number;
        export { maxFeatures_3 as maxFeatures };
        let pyramidOctaves_3: number;
        export { pyramidOctaves_3 as pyramidOctaves };
    }
}