/**
 * A prime-factor (PFA) complex-to-complex FFT.
 * <p>
 * The FFT length nfft must be composed of mutually prime factors from the
 * set { 2, 3, 4, 5, 7, 8, 9, 11, 13, 16 }. This restriction implies n
 * cannot exceed 720720 = 5 * 7 * 9 * 11 * 13 * 16.
 * <p>
 * References:
 * <ul><li>
 *   Temperton, C., 1985, Implementation of a self-sorting in-place prime
 *   factor fft algorithm:  Journal of Computational Physics, v. 58,
 *   p. 283-299.
 * </li><li>
 *   Temperton, C., 1988, A new set of minimum-add rotated rotated dft
 *   modules: Journal of Computational Physics, v. 75, p. 190-198.
 * </li></ul>
 */
export declare class FftPfa {
    private static readonly _P120;
    private static readonly _P142;
    private static readonly _P173;
    private static readonly _P222;
    private static readonly _P239;
    private static readonly _P281;
    private static readonly _P342;
    private static readonly _P354;
    private static readonly _P382;
    private static readonly _P415;
    private static readonly _P433;
    private static readonly _P464;
    private static readonly _P540;
    private static readonly _P559;
    private static readonly _P568;
    private static readonly _P587;
    private static readonly _P623;
    private static readonly _P642;
    private static readonly _P654;
    private static readonly _P663;
    private static readonly _P707;
    private static readonly _P748;
    private static readonly _P755;
    private static readonly _P766;
    private static readonly _P781;
    private static readonly _P822;
    private static readonly _P841;
    private static readonly _P866;
    private static readonly _P885;
    private static readonly _P900;
    private static readonly _P909;
    private static readonly _P923;
    private static readonly _P935;
    private static readonly _P939;
    private static readonly _P951;
    private static readonly _P959;
    private static readonly _P970;
    private static readonly _P974;
    private static readonly _P984;
    private static readonly _P989;
    private static readonly _P992;
    private static readonly _PONE;
    private static readonly _NFAC;
    private static readonly _kfac;
    private static readonly _NTABLE;
    private static readonly _ntable;
    private static readonly _ctable;
    /**
     * Determines whether the specified FFT length is valid.
     * @param nfft the FFT length.
     * @returns true, if FFT length is value; false, otherwise.
     */
    static IsValidNFFT(nfft: number): boolean;
    /**
     * Returns an FFT length optimized for memory.
     * <p>
     * The FFT length will be the smallest valid length that is not less than
     * the specified length n.
     * @param n the lower bound on FFT length.
     * @returns the FFT length.
     */
    static SmallNFFT(n: number): number;
    /**
     * Returns an FFT length optimized for speed.
     * <p>
     * The FFT length will be the fastest valid length that is not less than
     * the specified length n.
     * @param n the lower bound on FFT length.
     * @returns the FFT length.
     */
    static FastNFFT(n: number): number;
    /**
     * Prime-factor complex-to-complex FFT for 1D arrays.
     * @param sign the sign of the exponent in the Fourier transform.
     * @param nfft the FFT length.
     * @param z array[2*nfft] of nfft packed complex numbers.
     */
    static Transform(sign: number, nfft: number, z: number[]): void;
    /**
     * Prime-factor complex-to-complex multiple FFT.
     * <p>
     * Performs multiple transforms across the 2nd (slowest) dimension of a 2-D
     * array. In this version, z[0:nfft-1][0,2,4,...] contains the real parts,
     * and z[0:nfft-1][1,3,5,...] contains the imaginary parts.
     * @param sign the sign of the exponent in the Fourier transform.
     * @param n1 the number of transforms (fast dimension).
     * @param nfft the FFT length (slow dimension).
     * @param z array[nfft][2*n1] of n1*nfft packed complex numbers
     */
    static Transform2a(sign: number, n1: number, nfft: number, z: number[][]): void;
    /**
     * Prime-factor complex-to-complex multiple FFT.
     * <p>
     * Performs multiple transforms across the 2nd (slowest) dimension of a 2-D
     * array. In this version, z[0,2,4,...][0:n1-1] contains the real parts,
     * and z[1,3,5,...][0:n1-1] contains the imaginary parts.
     * @param sign the sign of the exponent in the Fourier transform.
     * @param n1 the number of transforms (fast dimension).
     * @param nfft the FFT length (slow dimension).
     * @param z array[nfft*2[n1] of nfft*n1 complex numbers.
     */
    static Transform2b(sign: number, n1: number, nfft: number, z: number[][]): void;
    private static _pfa2;
    private static _pfa3;
    private static _pfa4;
    private static _pfa5;
    private static _pfa7;
    private static _pfa8;
    private static _pfa9;
    private static _pfa11;
    private static _pfa13;
    private static _pfa16;
    private static _pfa2a;
    private static _pfa3a;
    private static _pfa4a;
    private static _pfa5a;
    private static _pfa7a;
    private static _pfa8a;
    private static _pfa9a;
    private static _pfa11a;
    private static _pfa13a;
    private static _pfa16a;
    private static _pfa2b;
    private static _pfa3b;
    private static _pfa4b;
    private static _pfa5b;
    private static _pfa7b;
    private static _pfa8b;
    private static _pfa9b;
    private static _pfa11b;
    private static _pfa13b;
    private static _pfa16b;
}