nmr-processing 17.1.0 → 17.1.2

package/nmr-processing.d.ts

@@ -1,37 +1,36 @@
-import { AnalizeMultipletOptions } from 'multiplet-analysis';
+import type { AnalizeMultipletOptions } from 'multiplet-analysis';
 import { BaseRegression } from 'ml-regression-base';
-import { DataReIm } from 'ml-spectra-processing';
-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 { GroupedDiaID } from 'openchemlib-utils';
-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 { LightLogger } from 'cheminfo-types';
-import { Logger } from 'cheminfo-types';
+import type { JoinBroadPeaksOptions } from 'ml-gsd';
+import type { LightLogger } 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 { 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;
@@ -78,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>;
 
@@ -114,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 {
@@ -297,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;
 
@@ -630,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) => {
@@ -653,7 +652,7 @@ export declare const Filters1D: {
     }>;
 };
 
-declare namespace Filters1DManager {
+export declare namespace Filters1DManager {
     export {
         applyFilters,
         reapplyFilters,
@@ -662,7 +661,6 @@ declare namespace Filters1DManager {
         applyFilter
     }
 }
-export { Filters1DManager }
 
 export declare const Filters2D: {
     [K in Filter2D['name']]: Extract<Filter2D, {
@@ -670,7 +668,7 @@ export declare const Filters2D: {
     }>;
 };
 
-declare namespace Filters2DManager {
+export declare namespace Filters2DManager {
     export {
         applyFilters_2 as applyFilters,
         reapplyFilters_2 as reapplyFilters,
@@ -679,7 +677,6 @@ declare namespace Filters2DManager {
         applyFilter_2 as applyFilter
     }
 }
-export { Filters2DManager }
 
 /**
  * Look for a multiplet based on the pattern name or abbreviation.
@@ -691,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;
@@ -759,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 {
@@ -794,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 {
@@ -890,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[];
 
@@ -910,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(
 /**
@@ -1112,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;
@@ -1202,7 +1201,8 @@ export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOpt
 export declare function markSolventPeaks<T extends NMRRange>(input: T[], solventSignals: NMRSignal1D[], options?: MarkSolventPeaksOptions): T[];
 
 declare interface MarkSolventPeaksOptions {
-    /** The NMR spectrometer frequency in MHz
+    /**
+     * The NMR spectrometer frequency in MHz
      * @default 400
      */
     frequency?: number;
@@ -1223,7 +1223,6 @@ export declare interface MatrixOptions {
     /**
      * Matrix generation filters
      * @default []
-     *
      */
     filters: Array<MatrixFilter & {
         options: object;
@@ -1251,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>;
 };
@@ -1262,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 {
@@ -1393,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;
 
@@ -1653,31 +1653,29 @@ export declare interface Peaks {
 
 /**
  * Filters impurities from a list of NMR peaks based on the specified options.
- *
  * @template T - The type of NMR peaks.
- * @param {T[]} peakList - The list of NMR peaks to be filtered.
- * @param {OptionsPeaksFilterImpurities} [options={}] - The options for filtering impurities.
- * @returns {T[]} The filtered list 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;
@@ -1770,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>;
 
@@ -2181,7 +2181,7 @@ export declare interface RangeToXYOptions {
     shape: Shape1D;
 }
 
-declare namespace RangeUtilities {
+export declare namespace RangeUtilities {
     export {
         getDiaIDs,
         getNbAtoms,
@@ -2193,7 +2193,6 @@ declare namespace RangeUtilities {
         checkSignalKinds
     }
 }
-export { RangeUtilities }
 
 declare function reapplyFilters(datum: Entry1D, options?: {
     filters?: Filter1DOptions[];
@@ -2346,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;
 
@@ -2376,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;
@@ -2427,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[];
 
@@ -2443,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>;
@@ -2503,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>>;
 
@@ -2551,7 +2563,6 @@ declare interface Simulate1DOptions {
 
 /**
  * This function will generate an object compatible with NMR-ium
- *
  * @param molecule
  * @param options
  */
@@ -2774,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>;
@@ -2783,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>;
@@ -2797,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(
  /**
@@ -2817,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(
  /**
@@ -2872,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;
  }>[];