import { type RemezType } from './remez-exchange.js';
type Vec = readonly number[] | Float64Array;
/** Polynomial/deconvolution division result: `signal = conv(divisor, quotient) + remainder`. */
export interface DeconvolveResult {
    quotient: number[];
    remainder: number[];
}
/**
 * FIR bandpass filter coefficients by the windowed-sinc method (Hamming
 * window): `h[n] = (f2·sinc(f2·(n−M/2)) − f1·sinc(f1·(n−M/2)))·hamming[n]`,
 * `M = numtaps−1`. `[f1, f2]` are cutoffs normalized to Nyquist (1 = Nyquist).
 * This is the array-cutoff (bandpass) case the scalar-only `firwin` in
 * `../signal-filter-extra.ts` didn't support (resolves the Phase-0 note).
 */
export declare function firwinBandpass(numtaps: number, cutoffs: readonly [number, number]): number[];
/**
 * Savitzky-Golay smoothing (`scipy.signal.savgol_filter`, default `mode='interp'`).
 * For each interior position, fits a degree-`polyorder` polynomial (via the
 * normal equations over a Vandermonde of the window offsets) to the centered
 * `windowLength`-point window and takes the fitted value at the center. Edge
 * points reuse the nearest full boundary window's fit, evaluated at the edge
 * point's actual offset from that window's center (scipy's boundary handling).
 * Exact on polynomials of degree <= `polyorder`.
 */
export declare function savgol(x: Vec, windowLength: number, polyorder: number): number[];
/**
 * FIR/polynomial deconvolution (`scipy.signal.deconvolve`): standard
 * synthetic long division so that `signal = conv(divisor, quotient) + remainder`,
 * with `quotient` of length `signal.length - divisor.length + 1` and
 * `remainder` the same length as `signal` (zero when `divisor` exactly divides).
 */
export declare function deconvolve(signal: Vec, divisor: Vec): DeconvolveResult;
/**
 * Wiener adaptive filter (`scipy.signal.wiener`-style, per-sample noise
 * estimate): local mean `m` and variance `v` over a sliding window of size
 * `mysize` (same-length, zero-padded at the edges — matches `convDirect`'s
 * `'same'` convention), noise power `= mean(v)`; output
 * `m + max(0, v−noise)/max(v, noise)·(x−m)` (0 where both `v` and `noise` are 0).
 */
export declare function wiener(x: Vec, mysize?: number): number[];
/**
 * Least-squares linear-phase FIR design (`scipy.signal.firls`): `bands` is a
 * flat list of `[lo, hi]` band-edge pairs (normalized to Nyquist, 1 = Nyquist)
 * and `desired` the corresponding response values at those edges (linearly
 * interpolated within each band; gaps between bands are unconstrained
 * transition regions). Solves the normal equations of the cosine-basis
 * representation of a symmetric (Type I odd-length / Type II even-length)
 * linear-phase filter against a dense trapezoid-quadrature sampling of the
 * specified bands, then maps the fitted basis coefficients back to taps.
 */
export declare function firls(numtaps: number, bands: readonly number[], desired: readonly number[]): number[];
/**
 * Optimal equiripple FIR design (`scipy.signal.remez`) via the exact
 * Parks-McClellan / Remez exchange algorithm (delegates to `remezExchange`).
 *
 * **Convention note:** unlike `firls` above (which follows `scipy.signal.firls`
 * with `1 = Nyquist` and one `desired` value per band *edge*), `remez` follows
 * `scipy.signal.remez` exactly: band edges are normalized to `[0, 0.5]`
 * (`fs = 1`, `0.5 = Nyquist`), and `desired`/`weight` carry one value per band
 * (length `bands.length / 2`). `type` is `'bandpass'` (symmetric, the default),
 * `'differentiator'`, or `'hilbert'` (antisymmetric). Coefficients match
 * `scipy.signal.remez` to machine precision.
 */
export declare function remez(numtaps: number, bands: readonly number[], desired: readonly number[], weight?: readonly number[], type?: RemezType): number[];
export {};
//# sourceMappingURL=fir-smoothing.d.ts.map