import { abs } from 'mathjs';
import { add } from 'mathjs';
import { arg } from 'mathjs';
import { BigNumber } from 'mathjs';
import { Complex } from 'mathjs';
import { index } from 'mathjs';
import { log10 } from 'mathjs';
import { MathCollection } from 'mathjs';
import { MathNumericType } from 'mathjs';
import { Matrix } from 'mathjs';
import { multiply } from 'mathjs';
import { pi } from 'mathjs';
import { PolarCoordinates } from 'mathjs';
import { pow } from 'mathjs';
import { round } from 'mathjs';
import { subset } from 'mathjs';
import { Unit } from 'mathjs';

export { abs }

export { add }

export { arg }

export { Complex }

/**
 * Creates a complex value or converts a value to a complex value.
 *
 * @see {@link https://mathjs.org/docs/reference/functions/complex.html | Math.js documentation for complex}
 */
export declare const complex: {
    (arg?: MathNumericType | string | PolarCoordinates): Complex;
    (arg?: MathCollection): MathCollection;
    (re: number, im: number): Complex;
};

/**
 * Represents frequency data and provides utility methods for unit conversion and wavelength calculation.
 *
 * @remarks
 * The `Frequency` class is designed to handle frequency points commonly used in RF, microwave,
 * and high-speed digital engineering. It maintains an internal unit and a set of frequency points,
 * allowing for seamless conversion between different frequency and wavelength units.
 *
 * ##### Key Features:
 * - **Unit Awareness**: Keeps track of whether frequencies are defined in Hz, MHz, GHz, etc.
 * - **Automatic Conversion**: Automatically scales frequency points when the `unit` property is changed.
 * - **Wavelength Utilities**: Provides getters and setters for wavelength ($\lambda = c/f$) in various metric units.
 *
 * @example
 * #### Basic Usage
 * ```typescript
 * import { Frequency } from 'rf-touchstone';
 *
 * const freq = new Frequency();
 * freq.unit = 'GHz';
 * freq.f_scaled = [1.0, 2.0, 5.0];
 *
 * console.log(freq.f_Hz); // [1e9, 2e9, 5e9]
 * console.log(freq.wavelength_mm); // [299.79, 149.90, 59.96]
 * ```
 */
export declare class Frequency {
    /**
     * Internal storage for frequency unit
     * Defaults to 'Hz' as the base SI unit for frequency
     */
    private _unit;
    /**
     * Sets the frequency unit. If frequency points already exist, they will be
     * automatically rescaled to the new unit.
     *
     * @param newUnit - The target frequency unit (Hz, kHz, MHz, or GHz).
     * @throws Error if the provided unit is invalid.
     */
    set unit(newUnit: FrequencyUnit);
    /**
     * Gets the current frequency unit.
     */
    get unit(): FrequencyUnit;
    /**
     * Internal storage for frequency points array
     * Each element represents a frequency point in the specified unit
     * @private
     */
    private _f_scaled;
    /**
     * Sets the array of frequency points in the current frequency unit.
     *
     * @param value - Array of numerical frequency points.
     * @throws Error if the input is not a non-negative number array.
     */
    set f_scaled(value: number[]);
    /**
     * Gets the array of frequency points in the current unit.
     */
    get f_scaled(): number[];
    /**
     * Private helper method to get frequency values in a target unit.
     * @param targetUnit - The key of the target frequency unit in FREQUENCY_MULTIPLIERS.
     * @returns Array of frequency points in the target unit.
     */
    private _getFrequencyInTargetUnit;
    /**
     * Internal helper to set frequency values from a source unit.
     * @param values - Array of frequency points.
     * @param sourceUnit - The source frequency unit key.
     */
    private _setFrequencyFromTargetUnit;
    /**
     * Gets the frequency points in Hertz (Hz).
     */
    get f_Hz(): number[];
    /**
     * Sets the frequency points in Hertz (Hz).
     */
    set f_Hz(values: number[]);
    /**
     * Gets the frequency points in Kilohertz (kHz).
     */
    get f_kHz(): number[];
    /**
     * Sets the frequency points in Kilohertz (kHz).
     */
    set f_kHz(values: number[]);
    /**
     * Gets the frequency points in Megahertz (MHz).
     */
    get f_MHz(): number[];
    /**
     * Sets the frequency points in Megahertz (MHz).
     */
    set f_MHz(values: number[]);
    /**
     * Gets the frequency points in Gigahertz (GHz).
     */
    get f_GHz(): number[];
    /**
     * Sets the frequency points in Gigahertz (GHz).
     */
    set f_GHz(values: number[]);
    /**
     * Gets the frequency points in Terahertz (THz).
     *
     * @remarks
     * THz is available for programmatic unit conversion but is NOT a valid file format unit.
     * Use this getter to convert existing frequency data to THz for calculations or display.
     */
    get f_THz(): number[];
    /**
     * Sets the frequency points in Terahertz (THz).
     *
     * @remarks
     * THz is available for programmatic unit conversion but is NOT a valid file format unit.
     * This setter converts THz values to the current internal unit (set via `unit` property).
     * Do not attempt to set `unit = 'THz'` as it will throw an error.
     */
    set f_THz(values: number[]);
    /**
     * Private helper method to get wavelength values in a target unit.
     * @param targetWavelengthUnit - The key of the target wavelength unit in WAVELENGTH_MULTIPLIERS_TO_M.
     * @returns Array of wavelength points in the target unit.
     */
    private _getWavelengthInTargetUnit;
    /**
     * Private helper method to set frequency values from wavelength values in a source unit.
     * @param values - Array of wavelength points in the source unit.
     * @param sourceWavelengthUnit - The key of the source wavelength unit in WAVELENGTH_MULTIPLIERS_TO_M.
     */
    private _setWavelengthFromTargetUnit;
    /**
     * Gets the wavelength in meters (m).
     */
    get wavelength_m(): number[];
    /**
     * Sets the wavelength in meters (m).
     *
     * @remarks
     * This is a bidirectional conversion: setting wavelength automatically calculates and updates
     * the underlying frequency points using the relationship f = c/λ, where c is the speed of light.
     * The resulting frequencies are stored in the current unit specified by the `unit` property.
     *
     * @throws Error if any wavelength value is zero (division by zero).
     */
    set wavelength_m(values: number[]);
    /**
     * Gets the wavelength in centimeters (cm).
     */
    get wavelength_cm(): number[];
    /**
     * Sets the wavelength in centimeters (cm).
     *
     * @remarks
     * Bidirectional conversion: Updates frequency points via f = c/λ.
     */
    set wavelength_cm(values: number[]);
    /**
     * Gets the wavelength in millimeters (mm).
     */
    get wavelength_mm(): number[];
    /**
     * Sets the wavelength in millimeters (mm).
     *
     * @remarks
     * Bidirectional conversion: Updates frequency points via f = c/λ.
     */
    set wavelength_mm(values: number[]);
    /**
     * Gets the wavelength in micrometers (μm).
     */
    get wavelength_um(): number[];
    /**
     * Sets the wavelength in micrometers (μm).
     *
     * @remarks
     * Bidirectional conversion: Updates frequency points via f = c/λ.
     */
    set wavelength_um(values: number[]);
    /**
     * Gets the wavelength in nanometers (nm).
     */
    get wavelength_nm(): number[];
    /**
     * Sets the wavelength in nanometers (nm).
     *
     * @remarks
     * Bidirectional conversion: Updates frequency points via f = c/λ.
     */
    set wavelength_nm(values: number[]);
}

/**
 * Multipliers for converting from any FrequencyUnit or THz to Hz
 */
export declare const FREQUENCY_MULTIPLIERS: Record<FrequencyUnit | 'THz', number>;

/**
 * Type representing the frequency unit.
 * - Hz: Hertz ($10^0$ Hz)
 * - kHz: Kilohertz ($10^3$ Hz)
 * - MHz: Megahertz ($10^6$ Hz)
 * - GHz: Gigahertz ($10^9$ Hz)
 */
export declare type FrequencyUnit = (typeof FrequencyUnits)[number];

/**
 * Supported frequency units in the Touchstone specification.
 * Note: THz is not officially supported as a file header unit in Touchstone v1.x/v2.x.
 *
 * @remarks
 * While THz can be accessed programmatically via the `f_THz` getter/setter for unit conversion,
 * it cannot be used as the `unit` property value. Attempting to set `frequency.unit = 'THz'`
 * will throw an error.
 */
export declare const FrequencyUnits: readonly ["Hz", "kHz", "MHz", "GHz"];

export { index }

export { log10 }

export { multiply }

export { pi }

export { pow }

/**
 * Create an array or matrix with a range of numbers.
 *
 * @see {@link https://mathjs.org/docs/reference/functions/range.html | Math.js documentation for range}
 */
export declare const range: {
    (str: string, includeEnd?: boolean): Matrix;
    (start: number | BigNumber, end: number | BigNumber, includeEnd?: boolean): Matrix;
    (start: number | BigNumber | Unit, end: number | BigNumber | Unit, step: number | BigNumber | Unit, includeEnd?: boolean): Matrix;
};

export { round }

/**
 * Speed of light in m/s
 */
export declare const SPEED_OF_LIGHT = 299792458;

export { subset }

/**
 * Represents a Touchstone file parser and generator.
 * Supports reading, manipulating, and writing Touchstone (.snp) files
 * following version 1.0 and 1.1 specifications.
 *
 * @remarks
 * #### Overview
 *
 * The **Touchstone file format** (typically with `.snp` extensions) is an industry-standard ASCII format
 * for representing n-port network parameters. It is widely used in Electronic Design Automation (EDA)
 * and by measurement equipment (like VNAs) to describe the performance of RF and microwave components.
 *
 * ##### Key Features:
 * - **File Extensions**: `.s1p`, `.s2p`, ... `.sNp` indicate a network with N ports.
 * - **Case Insensitivity**: Keywords and identifiers are case-insensitive.
 * - **Versions**: Full support for version 1.0 and 1.1. Version 2.0 is not currently supported.
 *
 * ---
 *
 * #### Touchstone File Structure
 *
 * A file consists of a header (comments and option line) followed by network data.
 *
 * ##### 1. Header Section
 *
 * - **Comment Lines**: Lines starting with `!` are stored in the `comments` array.
 * - **Option Line**: The line starting with `#` sets the global context.
 *   Example: `# GHz S MA R 50`
 *   - `GHz`: Frequency unit (`Hz`, `kHz`, `MHz`, or `GHz`).
 *   - `S`: Parameter type (`S`, `Y`, `Z`, `H`, or `G`).
 *   - `MA`: Data format (`MA` for magnitude-angle, `DB` for decibel-angle, or `RI` for real-imaginary).
 *     - RI: $A + j \cdot B$
 *     - MA: $A \cdot e^{j \cdot {\pi \over 180} \cdot B }$
 *     - DB: $10^{A \over 20} \cdot e^{j \cdot {\pi \over 180} \cdot B}$
 *   - `R 50`: Reference resistance in ohms (default is 50 ohms if omitted).
 *
 * ##### 2. Network Data Section
 *
 * Data is listed frequency by frequency. For a 2-port network, the format is:
 * `<frequency> <N11> <N21> <N12> <N22>` (where each NXx is a pair of values based on the format).
 *
 * ---
 *
 * #### References:
 * - {@link https://github.com/scikit-rf/scikit-rf scikit-rf: Open Source RF Engineering}
 * - {@link https://github.com/Nubis-Communications/SignalIntegrity SignalIntegrity: Signal and Power Integrity Tools}
 * - {@link https://books.google.com/books/about/S_Parameters_for_Signal_Integrity.html?id=_dLKDwAAQBAJ S-Parameters for Signal Integrity}
 * - {@link https://ibis.org/touchstone_ver2.1/touchstone_ver2_1.pdf Touchstone(R) File Format Specification (Version 2.1)}
 *
 * @example
 * #### Parsing a local file string
 * ```typescript
 * import { Touchstone } from 'rf-touchstone';
 *
 * const content = `
 * ! Simple 1-port S-parameter data
 * # MHz S RI R 50
 * 100 0.9 -0.1
 * 200 0.8 -0.2
 * `;
 * const ts = Touchstone.fromText(content, 1);
 * console.log(ts.parameter); // 'S'
 * console.log(ts.frequency.unit); // 'MHz'
 * ```
 */
export declare class Touchstone {
    /**
     * Utility to extract a filename from a URL or a file path string.
     *
     * @param pathOrUrl - The URL or string representation of a path.
     * @returns The filename part of the string.
     * @throws Error if the filename cannot be determined.
     */
    static getFilename(pathOrUrl: string): string;
    /**
     * Extracts the basename from a filename or path by removing the file extension.
     *
     * @remarks
     * This method intelligently handles both simple filenames and full paths.
     * If a path separator is detected (/ or \), it first extracts the filename,
     * then removes any file extension.
     *
     * @param filenameOrPath - The filename or full path to process.
     * @returns The basename without extension.
     *
     * @example
     * ```typescript
     * // Works with simple filenames
     * Touchstone.getBasename('myfile.s2p') // 'myfile'
     * Touchstone.getBasename('data.txt') // 'data'
     * Touchstone.getBasename('document.pdf') // 'document'
     *
     * // Also works with full paths
     * Touchstone.getBasename('/path/to/network.s2p') // 'network'
     * Touchstone.getBasename('C:\\data\\test.s3p') // 'test'
     * Touchstone.getBasename('https://example.com/file.txt') // 'file'
     *
     * // Files without extension remain unchanged
     * Touchstone.getBasename('noextension') // 'noextension'
     * ```
     */
    static getBasename(filenameOrPath: string): string;
    /**
     * Determines the number of ports based on the file extension (e.g., .s2p -> 2).
     *
     * @param filename - The filename or URL to inspect.
     * @returns The number of ports, or null if it cannot be determined.
     */
    static parsePorts(filename: string): number | null;
    /**
     * Creates a Touchstone instance from a raw text string.
     *
     * @param content - The raw text content of the Touchstone file
     * @param nports - The number of ports
     * @param name - Optional name for this Touchstone object (used for plotting legends and default save filename)
     * @returns A new Touchstone instance
     */
    static fromText(content: string, nports: number, name?: string): Touchstone;
    /**
     * Async helper to fetch, parse, and return a Touchstone instance from a URL.
     *
     * @param url - The URL of the Touchstone file.
     * @param nports - The expected number of ports. If null, it attempts to parse from the URL.
     * @returns A promise resolving to a Touchstone instance.
     * @throws Error if the fetch fails, or the number of ports cannot be determined.
     */
    static fromUrl(url: string, nports?: number | null): Promise<Touchstone>;
    /**
     * Reads a File object (typical in browser environments), parses it, and returns a Touchstone instance.
     *
     * @param file - The HTML5 File object to read.
     * @param nports - The expected number of ports. If null, it attempts to parse from the filename.
     * @returns A promise resolving to a Touchstone instance.
     * @throws Error if reading fails or the number of ports cannot be determined.
     */
    static fromFile(file: File, nports?: number | null): Promise<Touchstone>;
    /**
     * Name of the Touchstone file (without extension).
     * Used as default filename when saving and as legend label in plots.
     * Automatically set when using `fromUrl()` or `fromFile()`,
     * can be manually provided in `fromText()` or set directly.
     *
     * @example
     * ```typescript
     * const ts = await Touchstone.fromUrl('http://example.com/network.s2p')
     * console.log(ts.name) // 'network'
     * ```
     */
    name: string | undefined;
    /**
     * Array of comment strings extracted from the Touchstone file header (lines starting with `!`).
     */
    comments: string[];
    /**
     * Touchstone format: MA, DB, and RI
     */
    private _format;
    /**
     * Sets the Touchstone data format.
     * - RI: Real and Imaginary, i.e., $A + j \cdot B$
     * - MA: Magnitude and Angle (degrees), i.e., $A \cdot e^{j \cdot {\pi \over 180} \cdot B }$
     * - DB: Decibel and Angle (degrees), i.e., $10^{A \over 20} \cdot e^{j \cdot {\pi \over 180} \cdot B}$
     *
     * @param format - The target format (RI, MA, or DB).
     * @throws Error if the format is invalid.
     */
    set format(format: TouchstoneFormat | undefined | null);
    /**
     * Get the Touchstone format
     * @returns
     */
    get format(): TouchstoneFormat | undefined;
    /**
     * Type of network parameter: 'S' | 'Y' | 'Z' | 'G' | 'H'
     */
    private _parameter;
    /**
     * Sets the type of network parameters.
     * - S: Scattering parameters
     * - Y: Admittance parameters
     * - Z: Impedance parameters
     * - H: Hybrid-h parameters
     * - G: Hybrid-g parameters
     *
     * @param parameter - The target parameter type (S, Y, Z, G, or H).
     * @throws Error if the parameter type is invalid.
     */
    set parameter(parameter: TouchstoneParameter | undefined | null);
    /**
     * Get the type of network parameter
     */
    get parameter(): TouchstoneParameter | undefined | null;
    /**
     * Reference impedance(s) for the network parameters
     * Default: 50Ω
     */
    private _impedance;
    /**
     * Sets the reference impedance (resistance) in Ohms.
     * Default: 50Ω
     *
     * @param impedance - A single number for all ports, or an array of numbers (one per port).
     * @throws Error if the impedance value is invalid.
     */
    set impedance(impedance: TouchstoneImpedance);
    /**
     * Get the Touchstone impedance.
     * Default: 50Ω
     * @returns
     */
    get impedance(): TouchstoneImpedance;
    /**
     * The number of ports in the network
     */
    private _nports;
    /**
     * Sets the number of ports for the network.
     *
     * @param nports - The integer number of ports (must be >= 1).
     * @throws Error if the value is not a positive integer.
     */
    set nports(nports: number | undefined | null);
    /**
     * The number of ports in the network.
     */
    get nports(): number | undefined | null;
    /**
     * Frequency metadata and point array.
     */
    frequency: Frequency | undefined;
    /**
     * 3D array to store the network parameter data
     * - First dimension [i]: Output port index (0 to nports-1) - where signal exits
     * - Second dimension [j]: Input port index (0 to nports-1) - where signal enters
     * - Third dimension [k]: Frequency index
     *
     * For example: matrix[i][j][k] is the parameter from port j+1 to port i+1 at frequency k
     */
    private _matrix;
    /**
     * Directly sets the network parameter matrix.
     *
     * @param matrix - The 3D complex matrix to assign.
     */
    set matrix(matrix: TouchstoneMatrix | undefined | null);
    /**
     * Gets the current network parameter matrix (3D array).
     * Represents the S/Y/Z/G/H-parameters of the network.
     *
     * @remarks
     * Matrix Structure:
     * - First dimension [i]: Output port index (0 to nports-1) - where the signal exits
     * - Second dimension [j]: Input port index (0 to nports-1) - where the signal enters
     * - Third dimension [k]: Frequency point index
     *
     * @example
     * ```typescript
     * // For any N-port network (2-port, 4-port, etc.):
     * const s11 = touchstone.matrix[0][0][freqIdx] // S11: port 1 → port 1
     * const s21 = touchstone.matrix[1][0][freqIdx] // S21: port 1 → port 2
     * const s12 = touchstone.matrix[0][1][freqIdx] // S12: port 2 → port 1
     * const s22 = touchstone.matrix[1][1][freqIdx] // S22: port 2 → port 2
     *
     * // General pattern: Sij = matrix[i-1][j-1][freqIdx]
     * // where i is the output port number, j is the input port number
     * ```
     *
     * @returns The current network parameter matrix, or undefined if not set
     */
    get matrix(): TouchstoneMatrix | undefined | null;
    /**
     * Reads and parses a Touchstone format string into the internal data structure.
     *
     * @param string - The Touchstone format string to parse
     * @param nports - Number of ports in the network
     *
     * @throws {Error} If the option line is missing or invalid
     * @throws {Error} If multiple option lines are found
     * @throws {Error} If the impedance specification is invalid
     * @throws {Error} If the data format is invalid or incomplete
     *
     * @remarks
     * The method performs the following steps:
     * 1. Parses comments and option line
     * 2. Extracts frequency points
     * 3. Converts raw data into complex numbers based on format
     * 4. Stores the results in the matrix property
     *
     * @example
     * ```typescript
     * import { Touchstone } from 'rf-touchstone';
     *
     * const s1pString = `
     * ! This is a 1-port S-parameter file
     * # MHz S MA R 50
     * 100 0.99 -4
     * 200 0.80 -22
     * 300 0.707 -45
     * `;
     *
     * const touchstone = Touchstone.fromText(s1pString, 1);
     *
     * console.log(touchstone.comments); // Outputs: [ 'This is a 1-port S-parameter file' ]
     * console.log(touchstone.format); // Outputs: 'MA'
     * console.log(touchstone.parameter); // Outputs: 'S'
     * console.log(touchstone.impedance); // Outputs: 50
     * console.log(touchstone.nports); // Outputs: 1
     * console.log(touchstone.frequency?.f_scaled); // Outputs: [ 100, 200, 300 ]
     * console.log(touchstone.matrix); // Outputs: the parsed matrix data
     * ```
     */
    readContent(string: string, nports: number): void;
    /**
     * Validates the internal state of the Touchstone instance.
     * Performs comprehensive checks on all required data and matrix dimensions.
     *
     * @throws {Error} If any of the following conditions are met:
     * - Number of ports is undefined
     * - Frequency object is not initialized
     * - Frequency points array is empty
     * - Network parameter type is undefined
     * - Data format is undefined
     * - Network parameter matrix is undefined
     * - Matrix dimensions don't match with nports or frequency points
     *
     * @remarks
     * This method performs two main validation steps:
     * 1. Essential Data Validation:
     *    - Checks existence of all required properties
     *    - Ensures frequency points are available
     *
     * 2. Matrix Dimension Validation:
     *    - Verifies matrix row count matches port number
     *    - Ensures each row has correct number of columns
     *    - Validates frequency points count in each matrix element
     */
    validate(): void;
    /**
     * Generates a Touchstone format string from the internal data structure.
     *
     * @returns The generated Touchstone format string
     *
     * @throws {Error} If any required data is missing
     * @throws {Error} If the matrix dimensions are invalid
     *
     * @remarks
     * The generated string includes:
     * 1. Comments (if any)
     * 2. Option line with format, parameter type, and impedance
     * 3. Network parameter data in the specified format
     *
     * @example
     * ```typescript
     * import { Touchstone, Frequency } from 'rf-touchstone';
     * import { complex } from 'mathjs';
     *
     * const touchstone = new Touchstone();
     *
     * // Set properties and matrix data
     * touchstone.comments = ['Generated by rf-touchstone'];
     * touchstone.nports = 1;
     * touchstone.frequency = new Frequency();
     * touchstone.frequency.unit = 'GHz';
     * touchstone.frequency.f_scaled = [1.0, 2.0];
     * touchstone.parameter = 'S';
     * touchstone.format = 'MA';
     * touchstone.impedance = 50;
     * touchstone.matrix = [
     *   [ // Output port 1
     *     [complex(0.5, 0.1), complex(0.4, 0.2)] // S11 at each frequency
     *   ]
     * ];
     *
     * const s1pString = touchstone.writeContent();
     * console.log(s1pString);
     * // Expected output (approximately, due to floating point precision):
     * // ! Generated by rf-touchstone
     * // # GHz S MA R 50
     * // 1 0.5099 11.3099
     * // 2 0.4472 26.5651
     * ```
     */
    writeContent(): string;
}

/**
 * Type representing the Touchstone data format.
 * - RI: Real and Imaginary, i.e., $A + j \cdot B$
 * - MA: Magnitude and Angle (degrees), i.e., $A \cdot e^{j \cdot {\pi \over 180} \cdot B }$
 * - DB: Decibel (20*log10) and Angle (degrees), i.e., $10^{A \over 20} \cdot e^{j \cdot {\pi \over 180} \cdot B}$
 */
export declare type TouchstoneFormat = (typeof TouchstoneFormats)[number];

/**
 * Supported Touchstone data formats.
 * - RI: Real and Imaginary, i.e., $A + j \cdot B$
 * - MA: Magnitude and Angle (degrees), i.e., $A \cdot e^{j \cdot {\pi \over 180} \cdot B }$
 * - DB: Decibel (20*log10) and Angle (degrees), i.e., $10^{A \over 20} \cdot e^{j \cdot {\pi \over 180} \cdot B}$
 */
export declare const TouchstoneFormats: readonly ["RI", "MA", "DB"];

/**
 * The reference resistance(s) for the network parameters.
 * The token "R" (case-insensitive) followed by one or more reference resistance values.
 * Default: 50Ω
 *
 * For Touchstone 1.0, this is a single value for all ports.
 * For Touchstone 1.1, this can be an array of values (one per port)
 */
export declare type TouchstoneImpedance = number | number[];

/**
 * Network parameter matrix stored as complex numbers.
 *
 * @remarks
 * The matrix is a 3D array with the following dimensions:
 * - First dimension [i]: Output port index (0 to nports-1) - where the signal exits
 * - Second dimension [j]: Input port index (0 to nports-1) - where the signal enters
 * - Third dimension [k]: Frequency point index
 *
 * For example:
 * - `matrix[i][j][k]` represents the parameter from port j+1 to port i+1 at frequency k
 * - For S-parameters: `matrix[1][0][5]` is S₂₁ at the 6th frequency point
 *   (signal enters at port 1, exits at port 2)
 *
 * @example
 * ```typescript
 * // Access S21 (port 1 → port 2) at first frequency
 * const s21 = touchstone.matrix[1][0][0]
 *
 * // Access S11 (port 1 → port 1, reflection) at first frequency
 * const s11 = touchstone.matrix[0][0][0]
 * ```
 */
export declare type TouchstoneMatrix = Complex[][][];

/**
 * Type representing the network parameter type.
 * - S: Scattering
 * - Y: Admittance
 * - Z: Impedance
 * - H: Hybrid-h
 * - G: Hybrid-g
 */
export declare type TouchstoneParameter = (typeof TouchstoneParameters)[number];

/**
 * Supported network parameter types in Touchstone files.
 * - S: Scattering parameters
 * - Y: Admittance parameters
 * - Z: Impedance parameters
 * - H: Hybrid-h parameters
 * - G: Hybrid-g parameters
 */
export declare const TouchstoneParameters: readonly ["S", "Y", "Z", "G", "H"];

/**
 * Multipliers for converting from other wavelength units to meters
 */
export declare const WAVELENGTH_MULTIPLIERS_TO_M: Record<string, number>;

export { }