export * from './colormaps.js';
/**
 * Parâmetros da lib
 */
export interface SpectrogramParams {
    sampleRate?: number;
    scaleType?: 'Linear' | 'Mel';
    fMin?: number;
    fMax?: number;
    fftSize?: number;
    windowType?: 'None' | 'Cosine' | 'Hanning' | 'BH7';
    colormapName?: string;
    canvasHeight?: number;
    nTicks?: number;
    gainDb?: number;
    rangeDb?: number;
    targetWidth?: number;
    showFrequencyAxis?: boolean;
    showTimeAxis?: boolean;
    timeTickMinPx?: number;
    hopSize?: number;
}
export declare class SpectrogramGenerator {
    private params;
    /**
     * Cria uma instância do gerador de espectrograma.
     * @param options Parâmetros de configuração; valores omitidos usam defaults.
     */
    constructor(options?: SpectrogramParams);
    /**
     * Gera o espectrograma a partir de um vetor mono (Float32Array) e retorna um canvas.
     * - Respeita `scaleType` (Linear/Mel) no mapeamento vertical.
     * - Aplica margens apenas quando eixos são exibidos.
     * - Ajusta altura para `canvasHeight` e largura para `targetWidth` (ou window.innerWidth).
     * @param audioData Amostras de áudio mono.
     * @returns HTMLCanvasElement com o espectrograma renderizado.
     */
    generateSpectrogram(audioData: Float32Array): HTMLCanvasElement;
    /**
     * Exporta o espectrograma como PNG em alta resolução (retorna DataURL).
     * @param audioData Dados de áudio (mesmo usado no generateSpectrogram).
     * @param upscale Fator de escala para aumentar a resolução (default: 2).
     * @returns DataURL "image/png".
     */
    exportHighResPNG(audioData: Float32Array, upscale?: number): string;
    /**
     * Calcula o espectrograma (magnitude em dB) frame a frame.
     * @param audioData Sinal de entrada (após filtragem).
     * @param fftSize Tamanho da FFT.
     * @param windowType Tipo de janela.
     * @param hopSize Passo entre frames (amostras).
     * @returns Matriz [frame][bin] com magnitudes em dB (0..Nyquist).
     */
    private computeSpectrogram;
    /**
     * Cria um canvas offscreen com o espectrograma colorido e mapeado (Linear/Mel).
     * - Normalização por faixa dinâmica (ancorada no pico global).
     * - Calcula a duração total (em segundos) para o eixo de tempo.
     * @returns Objeto com canvas offscreen e metadados: { offscreenCanvas, specWidth, specHeight, globalMax, totalDurationSec }
     */
    private createOffscreenCanvas;
    /**
     * Desenha o eixo de frequências (Linear/Mel) à esquerda.
     * @param ctx Contexto 2D do canvas final.
     * @param scaleType 'Linear' ou 'Mel'.
     * @param fMin Frequência mínima (Hz).
     * @param fMax Frequência máxima (Hz).
     * @param top Topo da área útil.
     * @param height Altura da área útil.
     * @param leftMargin Largura da margem esquerda.
     * @param nTicks Número de divisões (ticks).
     */
    private drawFrequencyAxis;
    /**
     * Desenha o eixo de tempo (s) na base do gráfico.
     * @param ctx Contexto 2D.
     * @param durationSec Duração total do áudio representado (s).
     * @param left Posição X do início do conteúdo.
     * @param top Posição Y do topo do conteúdo.
     * @param width Largura do conteúdo.
     * @param height Altura do conteúdo.
     * @param bottomMargin Tamanho da margem inferior disponível para labels.
     * @param minPx Espaço mínimo entre marcas (px).
     */
    private drawTimeAxis;
    /**
     * Calcula um passo "agradável" de tempo para o eixo,
     * respeitando um espaçamento mínimo em pixels.
     * @param totalSec Duração total (s).
     * @param widthPx Largura em pixels.
     * @param minPx Espaçamento mínimo entre ticks (px).
     * @returns Passo em segundos.
     */
    private getNiceTimeStep;
    /**
     * Formata rótulos de tempo: "ms/s/mm:ss/hh:mm:ss"
     * @param sec Segundos.
     * @returns String formatada.
     */
    private formatTimeLabel;
    /**
     * FFT recursiva (radix-2). Requer tamanho potência de 2.
     * @param signal Sinal de entrada (janela já aplicada).
     * @returns Array de {re, im}.
     */
    private myFFT;
    /**
     * Aplica janela ao frame conforme `windowType`.
     * @param signal Frame de entrada.
     * @param windowType Tipo de janela.
     * @returns Frame janelado (ou o próprio se None/default).
     */
    private applyWindow;
    /**
     * Converte Hz -> Mel (escala de tons perceptual).
     * @param f Frequência em Hz.
     */
    private freqToMel;
    /**
     * Converte Mel -> Hz.
     * @param m Valor em Mel.
     */
    private melToFreq;
    /**
     * Gera ticks de frequência (Linear ou Mel) entre f_min e f_max.
     * @param f_min Hz mínimo.
     * @param f_max Hz máximo.
     * @param scaleType 'Linear' ou 'Mel'.
     * @param nTicks quantidade de divisões (mín. 2).
     * @returns Array de frequências para rotular o eixo.
     */
    private generateDynamicFreqTicks;
    /**
     * Resolve a cor [r,g,b] (0..255) para um valor normalizado [0..1].
     * Espera uma função colormap no escopo global: `window[colormapName](t)`.
     * @param value Valor normalizado (0..1).
     * @param colormapName Nome do colormap (ex.: 'hot').
     * @returns Array [r,g,b].
     */
    private getColormapValue;
    /**
     * Aplica filtragem FIR conforme parâmetros opcionais em this.params:
     * - filterType: 'none' | 'lowpass' | 'highpass' | 'bandpass' | 'notch'
     * - filterCutoffs: [cutoff] ou [lowCut, highCut] (Hz)
     * Observação: parâmetros não estão tipados no SpectrogramParams desta versão,
     * logo é feito cast para `any` aqui.
     * @param signal Sinal de entrada.
     * @returns Sinal filtrado (ou original, se não configurado).
     */
    private applyFilter;
    /**
     * Kernel FIR passa-baixa (windowed-sinc + Hamming).
     * @param cutoff Hz de corte.
     * @param sampleRate Hz.
     * @param kernelSize Tamanho ímpar do kernel.
     * @returns Coeficientes FIR.
     */
    private generateLowpassKernel;
    /**
     * Kernel FIR passa-alta = delta - lowpass(cutoff).
     * @param cutoff Hz de corte.
     * @param sampleRate Hz.
     * @param kernelSize Tamanho ímpar do kernel.
     * @returns Coeficientes FIR.
     */
    private generateHighpassKernel;
    /**
     * Kernel FIR passa-banda = lowpass(highCut) - lowpass(lowCut).
     * @param lowCut Hz de corte inferior.
     * @param highCut Hz de corte superior.
     * @param sampleRate Hz.
     * @param kernelSize Tamanho ímpar do kernel.
     * @returns Coeficientes FIR.
     */
    private generateBandpassKernel;
    /**
     * Kernel FIR rejeita-banda (notch) = delta - bandpass(lowCut, highCut).
     * @param lowCut Hz de corte inferior da banda rejeitada.
     * @param highCut Hz de corte superior da banda rejeitada.
     * @param sampleRate Hz.
     * @param kernelSize Tamanho ímpar do kernel.
     * @returns Coeficientes FIR.
     */
    private generateNotchKernel;
}