nmr-processing 17.0.0 → 17.1.1

package/nmr-processing.d.ts

@@ -1,36 +1,36 @@
-import { AnalizeMultipletOptions } from 'multiplet-analysis';
+import type { AnalizeMultipletOptions } from 'multiplet-analysis';
 import { BaseRegression } from 'ml-regression-base';
-import { DataXReIm } from 'ml-spectra-processing';
+import type { DataReIm } from 'ml-spectra-processing';
+import type { DataXReIm } from 'ml-spectra-processing';
 import { DataXY } from 'cheminfo-types';
-import { DoubleArray } from 'cheminfo-types';
+import type { DoubleArray } from 'cheminfo-types';
 import { ExponentialRegression } from 'ml-regression-exponential';
 import type { FilterXYType } from 'ml-signal-processing';
 import { FromTo } from 'cheminfo-types';
-import { GSDOptions } from 'ml-gsd';
+import type { GroupedDiaID } from 'openchemlib-utils';
+import type { GSDOptions } from 'ml-gsd';
 import { GSDPeakOptimized } from 'ml-gsd';
 import { GSDPeakOptimizedID } from 'ml-gsd';
-import { JoinBroadPeaksOptions } from 'ml-gsd';
+import type { JoinBroadPeaksOptions } from 'ml-gsd';
 import type { LightLogger } from 'cheminfo-types';
-import { Logger } from 'cheminfo-types';
+import type { Logger } from 'cheminfo-types';
 import { Matrix } from 'ml-matrix';
-import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
-import { Molecule } from 'openchemlib/full';
+import type { Molecule } from 'openchemlib/full';
 import type { Molecule as Molecule_2 } from 'openchemlib/minimal';
-import { NmrData1D } from 'cheminfo-types';
-import { NmrData2D } from 'cheminfo-types';
-import { NmrData2DContent } from 'cheminfo-types';
-import { NmrData2DFt } from 'cheminfo-types';
-import { NumberArray } from 'cheminfo-types';
-import { OCLMolecule } from 'cheminfo-types';
-import { OptimizePeaksOptions } from 'ml-gsd';
-import { OptionsSG1D } from 'spectrum-generator';
+import type { NmrData1D } from 'cheminfo-types';
+import type { NmrData2D } from 'cheminfo-types';
+import type { NmrData2DContent } from 'cheminfo-types';
+import type { NmrData2DFt } from 'cheminfo-types';
+import type { NumberArray } from 'cheminfo-types';
+import type { OCLMolecule } from 'cheminfo-types';
+import type { OptimizePeaksOptions } from 'ml-gsd';
+import type { OptionsSG1D } from 'spectrum-generator';
 import type { Peak2D as Peak2D_2 } from 'ml-matrix-peaks-finder';
-import { PeakXYWidth } from 'cheminfo-types';
+import type { PeakXYWidth } from 'cheminfo-types';
 import { PointXY } from 'cheminfo-types';
 import { Shape1D } from 'ml-peak-shape-generator';
-import { Spectrum2D } from 'spectrum-generator';
-import { TopicMolecule } from 'openchemlib-utils';
-import { XYEquallySpacedOptions } from 'ml-spectra-processing';
+import type { TopicMolecule } from 'openchemlib-utils';
+import type { XYEquallySpacedOptions } from 'ml-spectra-processing';
 import type { XYNumber } from 'spectrum-generator';
 
 declare function addDefaultSignal(range: Range_2): void;
@@ -42,6 +42,8 @@ export declare interface AirplsOptions {
     tolerance: number;
 }
 
+declare type AnalysisInfoSection = Record<string, string>;
+
 declare type Apodization1D = FilterFactory<Entry1D, Apodization2DOptions> & Pick<Apodization1DFilterOptions, 'name'>;
 
 declare interface Apodization1DFilterOptions extends BaseFilter {
@@ -75,6 +77,8 @@ export declare function apodizationXReIm(data: Required<NmrData1D>, options: Apo
 
 /**
  * pure function that applies a window function to the input data.
+ * @param data
+ * @param options
  */
 export declare function apodize(data: DoubleArray, options: ApplyWindowOptions): Float64Array<ArrayBufferLike>;
 
@@ -111,9 +115,6 @@ declare interface ApplyFilterOptions_2 {
  */
 declare function applyFilters(datum: Entry1D, filters?: Filter1DOptions[], options?: ApplyFilterOptions): void;
 
-/***
- * @param {object} Filters [{name:'',options:{}},{...}]
- */
 declare function applyFilters_2(datum: Entry2D, filters?: Filter2DOptions[], options?: ApplyFilterOptions_2): void;
 
 export declare interface ApplyWindowOptions {
@@ -127,6 +128,11 @@ export declare interface ApplyWindowOptions {
     output?: DoubleArray;
 }
 
+export declare interface AtomMapping {
+    label: string;
+    atom: number;
+}
+
 declare type AtomTypes = 'H' | 'C';
 
 export declare interface AutoPhaseCorrection2D {
@@ -289,8 +295,8 @@ export declare const carbonImpurities: DatabaseNMREntry[];
 
 /**
  * check whether integral based on its kind can be included in another operation or not
- * @param integral  integral
- * @returns {boolean}
+ * @param integral  - integral
+ * @returns
  */
 export declare function checkIntegralKind(integral: Integral): boolean;
 
@@ -300,6 +306,14 @@ declare function checkRangeKind(range: Range_2): boolean;
 
 declare function checkSignalKinds(range: Range_2, kinds: string[]): boolean;
 
+export declare interface ChemicalShift {
+    Element: string;
+    Shift: string;
+    Spincount: string;
+    Nucleicount: string;
+    Name: string;
+}
+
 declare type CommonField = SelectField | StringField | NumberField | BooleanField | LabelField;
 
 declare interface CompilePatternOptions {
@@ -311,8 +325,24 @@ declare interface CompilePatternOptions {
     };
 }
 
+export declare interface Coupling {
+    atomFrom: number;
+    atomTo: number;
+    atomLabelTo: string;
+    value: number;
+    key: string;
+    toDiaID: number;
+    pathLength: number;
+}
+
 export declare const couplingACSPatterns: string[];
 
+declare interface CouplingConstant {
+    Coupling: string;
+    Shift1: string;
+    Shift2: string;
+}
+
 export declare const couplingPatterns: OneLetterMultiplet[];
 
 export declare function createApodizationWindowData(options: {
@@ -343,6 +373,27 @@ export declare interface CreateSignals2DOptions {
     maxX: number;
 }
 
+/**
+ * CT results are stored in a CSV file with a specific format and a SDF file.
+ * This function will parse the CSV and return an object with the different sections.
+ * @param csv
+ * @returns
+ */
+declare function ctCSVParser(csv: string, options: {
+    logger: LightLogger;
+}): CtCSVParserResult;
+
+declare interface CtCSVParserResult {
+    'ANALYSIS INFO'?: AnalysisInfoSection;
+    SCORES?: ScoreEntry[];
+    SPINSYSTEMS?: ParsedRow[];
+    'CHEMICAL SHIFTS (ppm)'?: ParsedRow[];
+    'COUPLING CONSTANTS (Hz)'?: ParsedRow[];
+    LINESHAPES?: ParsedRow[];
+    QMGI?: ParsedRow[];
+    [key: string]: SectionData | undefined;
+}
+
 export declare function ctParser(sdf: string, csv: string, options: {
     OCL: {
         Molecule: typeof Molecule_2;
@@ -350,8 +401,8 @@ export declare function ctParser(sdf: string, csv: string, options: {
     logger?: LightLogger;
 }): {
     molecules: ParsedMolecule[];
-    sections: Record<string, any>;
-    groups: any[];
+    sections: ReturnType<typeof ctCSVParser>;
+    groups: GroupData[];
 };
 
 export declare type DataBaseLevelEntry = number | [number] | [number, number, number, number | null, number] | undefined | NMRSignalStatistics;
@@ -577,7 +628,8 @@ declare interface FilterFactory<EntryType, OptionsType> {
      * Filter function that process the data in place.
      */
     apply: (datum1D: EntryType, options: OptionsType) => void;
-    /** This function is called when the same filter had been applied
+    /**
+     * This function is called when the same filter had been applied
      *  it returns the value should be applied to the filter (reduce) and
      */
     reduce: (previousValue: OptionsType, newValue: OptionsType) => {
@@ -600,7 +652,7 @@ export declare const Filters1D: {
     }>;
 };
 
-declare namespace Filters1DManager {
+export declare namespace Filters1DManager {
     export {
         applyFilters,
         reapplyFilters,
@@ -609,7 +661,6 @@ declare namespace Filters1DManager {
         applyFilter
     }
 }
-export { Filters1DManager }
 
 export declare const Filters2D: {
     [K in Filter2D['name']]: Extract<Filter2D, {
@@ -617,7 +668,7 @@ export declare const Filters2D: {
     }>;
 };
 
-declare namespace Filters2DManager {
+export declare namespace Filters2DManager {
     export {
         applyFilters_2 as applyFilters,
         reapplyFilters_2 as reapplyFilters,
@@ -626,7 +677,6 @@ declare namespace Filters2DManager {
         applyFilter_2 as applyFilter
     }
 }
-export { Filters2DManager }
 
 /**
  * Look for a multiplet based on the pattern name or abbreviation.
@@ -638,12 +688,9 @@ export declare function findMultiplet(name: string): MatchingMultiplicity | unde
  * Finds a peak that can serve as a pivot point within specified boundaries.
  * The pivot is selected based on its y-value being above a threshold and its position
  * being closest to either boundary (minX or maxX).
- *
  * @param peaks - Array of points containing x and y coordinates
  * @param options - Configuration object for finding the pivot
- *
  * @returns The peak that serves as pivot point
- *
  * @throws {Error} If peaks array is empty
  */
 export declare function findPivot(peaks: PointXY[], options: XYObjectSidePointOptions): PointXY;
@@ -706,7 +753,7 @@ declare interface GaussianOptions {
 
 export declare function get13CAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get13CAssignmentsOptions): Promise<{
     score: any;
-    assignment: unknown[];
+    assignment: NMRRangeWithIntegration[];
 }[]>;
 
 export declare interface Get13CAssignmentsOptions {
@@ -741,7 +788,7 @@ export declare function get1DErrorFactor(spectrum: Entry1D): number;
 
 export declare function get1HAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get1HAssignmentsOptions): Promise<{
     score: any;
-    assignment: unknown[];
+    assignment: NMRRangeWithIntegration[];
 }[]>;
 
 export declare interface Get1HAssignmentsOptions {
@@ -837,12 +884,15 @@ export declare interface GetAutoAssignmentInput {
  * The approach is to find the peaks using GSD and then to enlarge the peaks
  * to determine the zones where the baseline is not present
  * @param data
+ * @param options
  */
 export declare function getBaselineZones(data: NmrData1D, options?: BaselineZoneOptions): BaselineCorrectionZone[];
 
 /**
  * Generate baseline zones by Dietrich method, it uses an iterative thresholding to discard signals zones over a power spectrum.
  * the implementation is based on the publication of Cobas et al (DOI: {@link https://doi.org/10.1016/j.jmr.2006.07.013})
+ * @param data
+ * @param options
  */
 export declare function getBaselineZonesByDietrich(data: NmrData1D, options?: BaselineZoneOptionsDietrich): BaselineCorrectionZone[];
 
@@ -857,6 +907,8 @@ declare function getDiaIDs(range: Range_2): string[];
 
 /**
  * calculate the frequency of a nucleus with respect to a reference nucleus
+ * @param nucleus
+ * @param observedNucleusData
  */
 export declare function getFrequency(
 /**
@@ -896,6 +948,19 @@ export declare interface GetPeakListOptions extends GSDOptions, OptimizePeaksOpt
 
 export declare function getShiftX(spectrum: Entry1D): number;
 
+export declare interface GroupData {
+    id: string;
+    molfile: string;
+    spinSystem: {
+        SSType: string;
+    };
+    couplingConstants: CouplingConstant[];
+    chemicalShifts: ChemicalShift[];
+    atomsMapping: AtomMapping[];
+    atomsMappingLookup: Record<string, number>;
+    signals?: NMRSignal1D[];
+}
+
 export declare const impurities: SolventImpurities;
 
 export declare type Impurity = Record<string, ImpuritySignal[]>;
@@ -1046,10 +1111,10 @@ export declare function mapRanges(ranges: Range_2[] | NMRRange[], spectrum: Entr
         delta: number;
         multiplicity: string;
         js: Jcoupling[];
+        nbAtoms?: number | undefined;
         atoms?: number[] | undefined;
         assignment?: string | undefined;
         diaIDs?: string[] | undefined;
-        nbAtoms?: number | undefined;
         integration?: number | undefined;
         statistics?: NMRSignalStatistics | undefined;
         kind: string;
@@ -1133,7 +1198,15 @@ export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOpt
     assignment?: string;
 }[];
 
-export declare function markSolventPeaks<T extends NMRRange>(input: T[], solventSignals: NMRSignal1D[], options?: any): T[];
+export declare function markSolventPeaks<T extends NMRRange>(input: T[], solventSignals: NMRSignal1D[], options?: MarkSolventPeaksOptions): T[];
+
+declare interface MarkSolventPeaksOptions {
+    /**
+     * The NMR spectrometer frequency in MHz
+     * @default 400
+     */
+    frequency?: number;
+}
 
 export declare type MatchingMultiplicity = MultipletDefinition & {
     match: string;
@@ -1150,7 +1223,6 @@ export declare interface MatrixOptions {
     /**
      * Matrix generation filters
      * @default []
-     *
      */
     filters: Array<MatrixFilter & {
         options: object;
@@ -1178,10 +1250,10 @@ declare type MatrixProperties = Record<string, Properties>;
 export declare function matrixToBoxPlot(input: NumberArray[], options?: {
     colors?: string[];
 }): {
-    color: any[];
+    color: (string | undefined)[];
+    median: Float64Array<ArrayBufferLike>;
     max: Float64Array<ArrayBufferLike>;
     min: Float64Array<ArrayBufferLike>;
-    median: Float64Array<ArrayBufferLike>;
     q1: Float64Array<ArrayBufferLike>;
     q3: Float64Array<ArrayBufferLike>;
 };
@@ -1189,7 +1261,7 @@ export declare function matrixToBoxPlot(input: NumberArray[], options?: {
 export declare function matrixToStocsy(matrix: NumberArray[], index: number, options?: MatrixToStocsyOptions): {
     y: number[];
     correlations: Float64Array<ArrayBuffer>;
-    color: any[];
+    color: (string | undefined)[];
 };
 
 declare interface MatrixToStocsyOptions {
@@ -1200,6 +1272,16 @@ declare interface MatrixToStocsyOptions {
     colors?: string[];
 }
 
+declare interface MinMaxContent {
+    z: Float64Array[];
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+}
+
 export declare interface MultipletDefinition {
     label: string;
     value: OneLetterMultiplet;
@@ -1310,6 +1392,7 @@ declare interface NMRZoneWithIds extends Omit<NMRZone, 'signals' | 'id'> {
 
 /**
  * The idea is to convert nucleus name like H1, proton or Fluorine19 to 1H and 19F.
+ * @param nucleus
  */
 export declare function normalizeNucleus(nucleus: string): string;
 
@@ -1337,12 +1420,6 @@ export declare interface ObservedNucleusData {
     frequency: number;
 }
 
-/**
- * This function will generate an object compatible with NMR-ium
- *
- * @param molecule
- * @param options
- */
 declare interface OneDOptions {
     proton: FromTo;
     carbon: FromTo;
@@ -1544,6 +1621,8 @@ declare interface ParsedMolecule {
     id: string;
 }
 
+declare type ParsedRow = Record<string, string>;
+
 export declare interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
     originalX?: number;
 }
@@ -1573,27 +1652,30 @@ export declare interface Peaks {
 }
 
 /**
- * Try to remove peaks of impurities.
+ * Filters impurities from a list of NMR peaks based on the specified options.
+ * @template T - The type of NMR peaks.
+ * @param peakList - The list of NMR peaks to be filtered.
+ * @param [options={}] - The options for filtering impurities.
+ * @returns The filtered list of NMR peaks.
  */
 export declare function peaksFilterImpurities<T extends NMRPeak1D>(peakList: T[], options?: OptionsPeaksFilterImpurities): T[];
 
 /**
  * Generates an NMR Free Induction Decay (FID) signal from a list of peaks.
- *
- * @param {Array<{ x: number, y: number }>} peaks - The list of peaks, where:
+ * @param peaks - The list of peaks, where:
  *   - `x` is the chemical shift in ppm.
  *   - `y` is the intensity of the peak.
- * @param {object} options - The options for FID generation.
- * @param {number} [options.from=0] - The start of the spectral window in ppm.
- * @param {number} [options.to=10] - The end of the spectral window in ppm.
- * @param {number} [options.nbPoints=1024] - The number of data points in the FID.
- * @param {number} [options.frequency=400] - The spectrometer frequency in MHz.
- * @param {NumberArray} [options.t2Relaxation] - An array of T2 relaxation times in milliseconds for each peak.
+ * @param options - The options for FID generation.
+ * @param [options.from=0] - The start of the spectral window in ppm.
+ * @param [options.to=10] - The end of the spectral window in ppm.
+ * @param [options.nbPoints=1024] - The number of data points in the FID.
+ * @param [options.frequency=400] - The spectrometer frequency in MHz.
+ * @param [options.t2Relaxation] - An array of T2 relaxation times in milliseconds for each peak.
  *   If not provided, all peaks are assigned a default T2 relaxation time of 100 ms.
- * @returns {{ re: Float64Array, im: Float64Array }} - The generated FID signal, where:
+ * @returns - The generated FID signal, where:
  *   - `re` is the real part of the FID.
  *   - `im` is the imaginary part of the FID.
- **/
+ */
 export declare function peaksToFID(peaks: Array<{
     x: number;
     y: number;
@@ -1686,7 +1768,9 @@ export declare interface PolynomialOptions {
 
 /**
  * Generate the 2D correlation nmr peaks based on the number of bonds between a pair of atoms
- * @returns {Promise<object>} - object with molfile, diaIDs, 1D and 2D signals, joined signals, ranges and zones.
+ * @param molecule
+ * @param options
+ * @returns - object with molfile, diaIDs, 1D and 2D signals, joined signals, ranges and zones.
  */
 export declare function predict(molecule: Molecule, options?: PredictAllOptions): Promise<Predicted>;
 
@@ -1777,22 +1861,58 @@ declare interface PredictCOSYOptions {
 export declare interface Predicted {
     molfile: string;
     molfileWithH: string;
-    hoses: any[];
-    diaIDs: any[] | undefined;
-    groupedDiaIDs: any[];
+    hoses: string[];
+    diaIDs: string[] | undefined;
+    groupedDiaIDs: GroupedDiaID[];
     moleculeWithHydrogens: Molecule;
-    distanceMatrix: any[];
+    distanceMatrix: NumberArray[];
     spectra: PredictedSpectra;
 }
 
-export declare interface PredictedSpectra {
+export declare interface Predicted1DSpectra {
     proton?: PredictionBase1D;
     carbon?: PredictionBase1D;
+}
+
+export declare interface Predicted2DSpectra {
     cosy?: PredictionBase2D;
     hsqc?: PredictionBase2D;
     hmbc?: PredictionBase2D;
 }
 
+export declare interface PredictedSpectra extends Predicted1DSpectra, Predicted2DSpectra {
+}
+
+declare interface PredictedSpectrum1D {
+    data: {
+        x: NumberArray;
+        re: NumberArray;
+        im: null;
+    };
+    info: Spectrum1DInfo;
+    ranges: {
+        values: Array<{
+            from: number;
+            to: number;
+        }>;
+    };
+}
+
+declare interface PredictedSpectrum2D {
+    data: {
+        rr: MinMaxContent & {
+            noise: number;
+        };
+    };
+    info: Spectrum2DInfo;
+    zones: {
+        values: Array<{
+            x: FromTo;
+            y: FromTo;
+        }>;
+    };
+}
+
 /**
  * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
  * @returns {Promise<object>} - object with molfile, diaIDs, 2D signals joined signals and zones.
@@ -1920,12 +2040,14 @@ export declare interface PredictProtonOptions {
     cache?: PredictionCacheFn;
 }
 
-export declare function predictSpectra(molecule: Molecule, options?: PredictAllSpectraOptions): Promise<{
-    spectra: any[];
-    molecules: {
+export declare function predictSpectra(molecule: Molecule, options?: PredictAllSpectraOptions): Promise<PredictSpectraResult>;
+
+declare interface PredictSpectraResult {
+    spectra: Array<PredictedSpectrum1D | PredictedSpectrum2D>;
+    molecules: Array<{
         molfile: string;
-    }[];
-}>;
+    }>;
+}
 
 declare type Properties = ListField | SelectField | StringField | NumberField | BooleanField | LabelField;
 
@@ -2059,7 +2181,7 @@ export declare interface RangeToXYOptions {
     shape: Shape1D;
 }
 
-declare namespace RangeUtilities {
+export declare namespace RangeUtilities {
     export {
         getDiaIDs,
         getNbAtoms,
@@ -2071,7 +2193,6 @@ declare namespace RangeUtilities {
         checkSignalKinds
     }
 }
-export { RangeUtilities }
 
 declare function reapplyFilters(datum: Entry1D, options?: {
     filters?: Filter1DOptions[];
@@ -2083,6 +2204,11 @@ declare function reapplyFilters_2(datum: Entry2D, options?: {
     logger?: Logger;
 }): void;
 
+export declare function reimComplexBackwardLinearPrediction(data: DataReIm, options: BackwardLPOptions): {
+    re: Float64Array<ArrayBuffer>;
+    im: Float64Array<ArrayBuffer>;
+};
+
 declare function resetDiaIDs(range: Range_2): void;
 
 declare interface RestrictionByCS {
@@ -2103,6 +2229,13 @@ export declare interface ResurrectOptions {
     logger?: Logger;
 }
 
+declare interface ScoreEntry {
+    key: string;
+    value: string;
+}
+
+declare type SectionData = AnalysisInfoSection | ScoreEntry[] | ParsedRow[];
+
 declare interface SelectField extends Field<any> {
     type: 'select';
     choices: any[];
@@ -2212,6 +2345,8 @@ declare interface SignalAxis {
  * Join couplings smaller than a define tolerance.
  * The resulting coupling should be an average of the existing one.
  * If pathLength is specified and is not always the same this property will be removed.
+ * @param signal
+ * @param options
  */
 export declare function signalJoinCouplings(signal: NMRSignal1D, options?: SignalJoinCouplingsOptions): NMRSignal1D;
 
@@ -2242,7 +2377,9 @@ export declare const SignalKindsToInclude: string[];
 
 /**
  * Return
- * @param {*} signal
+ * @param signal
+ * @param options
+ * @param options.acsFormat
  */
 export declare function signalMultiplicityPattern(signal: NMRSignal1D, options?: {
     acsFormat?: boolean;
@@ -2255,7 +2392,15 @@ declare interface SignalProcessingFilter extends BaseFilter {
     value: MatrixOptions;
 }
 
-export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): Spectrum2D;
+export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+    z: Float64Array<ArrayBufferLike>[];
+};
 
 declare interface Signals2DToZOptions {
     /**
@@ -2285,6 +2430,9 @@ declare interface Signals2DToZOptions {
 
 /**
  * Join signals if all the same diaID
+ * @param signals
+ * @param options
+ * @returns
  */
 export declare function signalsJoin(signals: NMRSignal1D[], options?: SignalsJoinOptions): Signal1DWidthJsAndDiaID[];
 
@@ -2301,6 +2449,8 @@ export declare interface SignalsJoinOptions {
  * It does not propagate the hamiltonian of the spin system, instead it simulate all the
  * frequencies in the spectrum (including second order) and add all the waves in a real and
  * imaginary parts, that is why the couplings should be assigned in order to generate the spin system.
+ * @param signals
+ * @param options
  */
 export declare function signalsToFID(signals: NMRSignal1D[], options: SignalsToFIDOptions): {
     re: Float64Array<ArrayBuffer>;
@@ -2361,11 +2511,15 @@ declare interface SignalsToRangesOptions {
 
 /**
  * Generate a spectrum from an array of singals
+ * @param signals
+ * @param options
  */
 export declare function signalsToXY(signals: NMRSignal1D[], options?: OptionsSignalsToXY): DataXY<Float64Array<ArrayBufferLike>>;
 
 /**
  * This function simulates a one dimensional nmr spectrum. This function returns an array containing the relative intensities of the spectrum in the specified simulation window (from-to).
+ * @param spinSystemInput
+ * @param options
  */
 export declare function simulate1D(spinSystemInput: SpinSystem, options?: Simulate1DOptions): DataXY<Float64Array<ArrayBufferLike>>;
 
@@ -2407,6 +2561,11 @@ declare interface Simulate1DOptions {
     shape?: Shape1D;
 }
 
+/**
+ * This function will generate an object compatible with NMR-ium
+ * @param molecule
+ * @param options
+ */
 declare interface SimulationOptions {
     frequency: number;
     oneD?: Partial<OneDOptions>;
@@ -2470,6 +2629,25 @@ export declare interface SpectraData2DWithIds extends Omit<SpectraData2D, 'zones
 
 export declare type SpectraDataWithIds = SpectraData1DWithIds | SpectraData2DWithIds;
 
+declare interface Spectrum1DInfo {
+    nucleus: string;
+    dimension: number;
+    isComplex: boolean;
+    originFrequency: number;
+    baseFrequency: number;
+    pulseSequence: string;
+    experiment: string;
+    isFt: boolean;
+}
+
+declare interface Spectrum2DInfo {
+    nucleus: string[];
+    originFrequency: string;
+    baseFrequency: string | number;
+    pulseSequence: string;
+    experiment: string;
+}
+
 export declare interface SpinSystem {
     /**
      * isolated clusters from a similarity/connectivity matrix
@@ -2607,6 +2785,8 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
  /**
   * Predict back points by singular value decomposition.
   * to append the predicted points is it needed to append nbPoints zeros at the beginning of input data.
+  * @param data
+  * @param options
   */
  export declare function xBackwardLinearPrediction(data: DoubleArray, options: BackwardLPOptions): {
      output: Float64Array<ArrayBufferLike>;
@@ -2616,6 +2796,8 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
  /**
   * Predict back points by singular value decomposition.
   * to append the predicted points is it needed to append nbPoints zeros at the beginning of input data.
+  * @param data
+  * @param options
   */
  export declare function xForwardLinearPrediction(data: DoubleArray, options: ForwardLPOptions): {
      output: Float64Array<ArrayBufferLike>;
@@ -2630,6 +2812,8 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
  /**
   * Determination of J couplings by recursive deconvolution in the frequency domain,
   * it use the method published by Damien Jeannerat and Geoffrey Bodenhausen @link{https://doi.org/10.1006/jmre.1999.1845}
+  * @param data
+  * @param options
   */
  export declare function xreimMultipletAnalysis(
  /**
@@ -2650,11 +2834,15 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
 
  /**
   * Detect peaks, optimize parameters and compile multiplicity if required.
+  * @param data
+  * @param options
   */
  export declare function xyAutoRangesPicking(data: DataXY<Float64Array>, options: OptionsXYAutoRangesPicking): NMRRange[];
 
  /**
   * Estimate the diffusion coefficient of an independent component by fitting of imput data with the Stejskal–Tanner equation.
+  * @param data
+  * @param options
   */
  export declare function xyCalculateDiffussionCoefficient(
  /**
@@ -2705,10 +2893,12 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
   * Bidimensional automatic phase correction, based in the idea to see the spectrum as a bitmap,
   * where the number of white pixels will be bigger in a phased spectrum (whitening concept). Further information can be found in the
   * publication of Balacco and Cobas (DOI: {@link https://doi.org/10.1002/mrc.2394}). This method use a incremental search instead of simplex algorithm.
+  * @param data
+  * @param options
   */
  export declare function xyzAutoPhaseCorrection(data: NmrData2DFt, options?: AutoPhaseCorrection2D): Required<PhaseCorrectionTwoDOptions>;
 
- export declare function xyzAutoSignalsPicking(spectraData: NmrData2DContent, options: XYZAutoSignalsPickingOptions): NMRSignal2DWithID<matrixPeakFinders.Peak2D & {
+ export declare function xyzAutoSignalsPicking(spectraData: NmrData2DContent, options: XYZAutoSignalsPickingOptions): NMRSignal2DWithID<Peak2D_2 & {
      id: string;
  }>[];