nmr-processing 19.5.2 → 20.0.1

package/dist/nmr-processing.d.ts

@@ -81,7 +81,7 @@ import type { PhaseCorrection2DOptions } from '@zakodium/nmr-types';
 import type { PhaseCorrectionTwoDFilter } from '@zakodium/nmr-types';
 import type { PhaseCorrectionTwoDOptions } from '@zakodium/nmr-types';
 import { PointXY } from 'cheminfo-types';
-import type { Range } from '@zakodium/nmr-types';
+import type { Range as Range_2 } from '@zakodium/nmr-types';
 import type { Ranges } from '@zakodium/nmr-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
 import type { Shapes } from '@zakodium/nmr-types';
@@ -89,6 +89,7 @@ import type { Shift2DXFilterOptions } from '@zakodium/nmr-types';
 import type { Shift2DYFilterOptions } from '@zakodium/nmr-types';
 import type { ShiftXFilterOptions } from '@zakodium/nmr-types';
 import type { ShiftXOptions } from '@zakodium/nmr-types';
+import { SignalKind } from '@zakodium/nmr-types';
 import type { SignalProcessingFilter } from '@zakodium/nmr-types';
 import type { SineBellOptions } from '@zakodium/nmr-types';
 import type { SymmetrizeCosyLikeOptions } from '@zakodium/nmr-types';
@@ -103,8 +104,6 @@ import type { ZeroFillingOptions } from '@zakodium/nmr-types';
 import type { Zone } from '@zakodium/nmr-types';
 import type { Zones } from '@zakodium/nmr-types';
 
-declare function addDefaultSignal(range: Range): void;
-
 declare type Apodization1D = FilterFactory<Entry1D, Apodization1DOptions> & Pick<Apodization1DFilterOptions, 'name'>;
 
 declare type ApodizationDimension1 = FilterFactory<Entry2D, Apodization2D1Options> & Pick<ApodizationDimension1Options, 'name'>;
@@ -326,10 +325,14 @@ declare interface CalculateT1OptionsOptimization {
     options?: Partial<LevenbergMarquardtOptionsDefault> & LevenbergMarquardtOptionsOverride;
 }
 
+/**
+ * Common laboratory solvents database (carbon).
+ * @see https://doi.org/10.1021/jo971176v
+ */
 export declare const carbonImpurities: DatabaseNMREntry[];
 
 /**
- * check whether integral based on its kind can be included in another operation or not
+ * Check whether integral based on its kind can be included in another operation or not.
  * @param integral  - integral
  * @returns
  */
@@ -337,9 +340,7 @@ export declare function checkIntegralKind(integral: Integral): boolean;
 
 export declare function checkMultiplicity(multiplicity: string, rejected?: OneLetterMultiplet[]): boolean;
 
-declare function checkRangeKind(range: Range): boolean;
-
-declare function checkSignalKinds(range: Range, kinds: string[]): boolean;
+declare function checkSignalKinds(range: Range_2, kinds: ReadonlySet<SignalKind>): boolean;
 
 declare interface CompilePatternOptions {
     observedFrequencies?: number[] | Float64Array;
@@ -488,11 +489,6 @@ export declare interface DataResurrect {
 
 export declare type DataXReOptionalIm = Omit<DataXReIm, 'im'> & Partial<Pick<DataXReIm, 'im'>>;
 
-export declare const DatumKind: {
-    signal: string;
-    mixed: string;
-};
-
 export declare const default1DApodization: Shapes;
 
 declare const defaultDirectOptimizationOptions: {
@@ -557,6 +553,11 @@ declare interface EnableFilterOptions {
     logger?: Logger;
 }
 
+/**
+ * Takes a potentially invalid signal kind and makes sure a valid kind is returned.
+ */
+export declare function ensureValidSignalKind(kind: string | undefined): SignalKind;
+
 declare interface Entry1D {
     id?: string;
     data: NmrData1D;
@@ -941,8 +942,6 @@ export declare function getDatabase(url?: string, options?: {
     format?: 'tsv' | 'json';
 }): Promise<DatabaseNMREntry[]>;
 
-declare function getDiaIDs(range: Range): string[];
-
 /**
  * @deprecated use getRelativeFrequency instead
  */
@@ -956,8 +955,6 @@ declare interface GetKernelOptions {
 
 declare function getLineShapes(l: LineShapeData[]): LineShapeResult[];
 
-declare function getNbAtoms(range: Range, signalIndex?: number): number;
-
 export declare function getPeakDelta(peak: Peak1D | NMRPeak1D, shiftTarget: ShiftTarget, shift: number): {
     originalX: number;
     x: number;
@@ -1038,22 +1035,11 @@ declare interface HOSEPrediction {
 
 declare type ID = string;
 
-export declare const impurities: SolventImpurities;
-
-export declare type Impurity = Record<string, ImpuritySignal[]>;
-
-export declare interface ImpuritySignal {
-    proton: string;
-    coupling: number;
-    multiplicity: string;
-    shift: number;
-}
-
 export declare function isEmptyMolecule(molecule: Molecule): boolean;
 
 export declare function isMolfileNotEmpty(molFile?: string): molFile is string;
 
-export declare function isRangeExists(range: Pick<Range, 'from' | 'to'>, spectrum: Entry1D, error: number): boolean;
+export declare function isRangeExists(range: Pick<Range_2, 'from' | 'to'>, spectrum: Entry1D, error: number): boolean;
 
 export declare function isZoneExists(zone: Pick<Zone, 'x' | 'y'>, spectrum: Entry2D, error: Zone2DError): boolean;
 
@@ -1113,16 +1099,7 @@ declare type MakeMandatory<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
 
-export declare function mapIntegrals(integrals: Integral[], spectrum: Entry1D, shiftTarget?: ShiftTarget): {
-    absolute: number;
-    originalFrom: number;
-    originalTo: number;
-    from: number;
-    to: number;
-    id: string;
-    integral: number;
-    kind: string;
-}[];
+export declare function mapIntegrals(integrals: Integral[], spectrum: Entry1D, shiftTarget?: ShiftTarget): Integral[];
 
 declare interface MapOptions {
     checkIsExisting?: boolean;
@@ -1131,7 +1108,7 @@ declare interface MapOptions {
 
 export declare function mapPeaks(peaks: Peak1D[], spectrum: Entry1D, options?: MapOptions): Peak1D[];
 
-export declare function mapRanges(ranges: Range[] | NMRRange[], spectrum: Entry1D, options?: MapOptions): Range[];
+export declare function mapRanges(ranges: Range_2[] | NMRRange[], spectrum: Entry1D, options?: MapOptions): Range_2[];
 
 export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOptions): {
     signals: {
@@ -1149,7 +1126,7 @@ export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOpt
             };
         }[] | undefined;
         id: string;
-        kind: string;
+        kind: SignalKind;
         x: {
             originalDelta: number;
             delta: number;
@@ -1167,7 +1144,7 @@ export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOpt
             pathLength?: number | FromTo;
         };
     }[];
-    kind: string;
+    kind: SignalKind;
     x: {
         from: number;
         to: number;
@@ -1280,7 +1257,7 @@ export declare interface NMRSignal2D<T extends Peak2D = Peak2D> {
     };
     id?: string;
     peaks?: T[];
-    kind?: string;
+    kind?: SignalKind;
 }
 
 export declare type NMRSignal2DWithID<T extends Peak2D = Peak2D> = MakeMandatory<NMRSignal2D<T>, 'id'>;
@@ -1380,28 +1357,6 @@ declare interface OptimizeSignalsOptionsLevenbergMarquardtOptimization {
 
 export declare type OptimizeSignalsOptionsOptimization = OptimizeSignalsOptionsDirectOptimization | OptimizeSignalsOptionsLevenbergMarquardtOptimization;
 
-export declare interface OptionsPeaksFilterImpurities {
-    /**
-     * Frequency of the spectrometer to convert peak width from Hz to ppm
-     * @default 400
-     */
-    frequency?: number;
-    /**
-     * Solvent name.
-     */
-    solvent?: string;
-    /**
-     * tolerance in ppm to assign a impurity.
-     * @default 0.025
-     */
-    error?: number;
-    /**
-     * If it is true, it remove the peaks otherwise it assigns the kind of the signal with the name of the impurity
-     * @default false
-     */
-    remove?: boolean;
-}
-
 declare interface OptionsPeaksToRanges {
     /**
      * Number of hydrogens or some number to normalize the integration data. If it's zero return the absolute integration value
@@ -1531,7 +1486,7 @@ export declare interface OptionsXYAutoPeaksPicking extends Partial<GetPeakListOp
 
 declare interface OptionsXYAutoRangesPicking {
     peakPicking: OptionsXYAutoPeaksPicking;
-    impurities?: OptionsPeaksFilterImpurities;
+    impurities?: PeaksMarkProtonLabSolventsOptions;
     ranges?: OptionsPeaksToRanges;
     logger?: Logger;
 }
@@ -1579,14 +1534,22 @@ export declare interface Peak2DSeries {
     z: number[];
 }
 
-/**
- * Filters impurities from a list of NMR peaks based on the specified options.
- * @template T - The type of NMR peaks.
- * @param peaks - 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>(peaks: T[], options?: OptionsPeaksFilterImpurities): T[];
+declare interface PeaksMarkProtonLabSolventsOptions {
+    /**
+     * Frequency of the spectrometer to convert peak width from Hz to ppm
+     * @default 400
+     */
+    frequency?: number;
+    /**
+     * Solvent name.
+     */
+    solvent?: string;
+    /**
+     * tolerance in ppm to assign an impurity.
+     * @default 0.025
+     */
+    error?: number;
+}
 
 /**
  * Generates an NMR Free Induction Decay (FID) signal from a list of peaks.
@@ -1952,6 +1915,10 @@ export declare interface PredictSpectraResult {
     }>;
 }
 
+/**
+ * Common laboratory solvents database (proton).
+ * @see https://doi.org/10.1021/jo971176v
+ */
 export declare const protonImpurities: DatabaseNMREntry[];
 
 export declare function rangeFromSignal(signal: NMRSignal1D, options?: RangeFromSignalOptions): {
@@ -2098,13 +2065,6 @@ export declare interface RangeToXYOptions {
 
 export declare namespace RangeUtilities {
     export {
-        getDiaIDs,
-        getNbAtoms,
-        setNbAtoms,
-        resetDiaIDs,
-        unlink,
-        addDefaultSignal,
-        checkRangeKind,
         checkSignalKinds
     }
 }
@@ -2124,8 +2084,6 @@ export declare function reimComplexBackwardLinearPrediction(data: DataReIm, opti
     im: Float64Array<ArrayBuffer>;
 };
 
-declare function resetDiaIDs(range: Range): void;
-
 declare interface RestrictionByCS {
     chemicalShiftRestriction: boolean;
     tolerance: Record<string, number>;
@@ -2144,8 +2102,6 @@ export declare interface ResurrectOptions {
     logger?: Logger;
 }
 
-declare function setNbAtoms(range: Range, signalIndex?: number): void;
-
 declare type Shape1DWithFWHM = Omit<Shape1D, 'fwhm'> & {
     fwhm: number;
 };
@@ -2249,12 +2205,9 @@ export declare interface SignalJoinCouplingsOptions {
     ignoreDiaIDs?: boolean;
 }
 
-export declare const SignalKinds: Array<{
-    label: string;
-    value: string;
-}>;
+export declare const signalKindLabelMapping: Readonly<Record<SignalKind, string>>;
 
-export declare const SignalKindsToInclude: string[];
+export declare const signalKindsToInclude: ReadonlySet<SignalKind>;
 
 /**
  * Return
@@ -2474,8 +2427,6 @@ declare interface SineSquare<ShapeOption = SineBellOptions> {
     options: ShapeOption;
 }
 
-export declare type SolventImpurities = Record<string, Impurity>;
-
 export declare function solventSuppression<T extends NMRPeak1D>(peakList: T[], solvent: NMRSignal1D[], options?: {
     markSolventPeaks?: boolean;
     solventZoneExtension?: number;
@@ -2616,301 +2567,286 @@ declare interface TwoDOptions {
     };
 }
 
-declare function unlink(range: Range, options?: UnlinkOptions): Range;
+export declare function updateIntegralsRelativeValues(spectrum: Entry1D, forceCalculateIntegral?: boolean): void;
+
+export declare function updateRanges(spectrum: Entry1D): void;
+
+export declare function updateRangesRelativeValues(spectrum: Entry1D, forceCalculateIntegral?: boolean): void;
+
+export declare type WindowFunctions = Exponential | SineBell | SineSquare | Traf | Gaussian;
 
 /**
- *
- * @param {object} range
- * @param {String('both' | 'range' | 'signal')} unlinkType
-     * @param {object} options
-     * @param {number} [options.signalIndex]
-     * @returns {object}
-     */
- declare interface UnlinkOptions {
-     unlinkType?: 'both' | 'range' | 'signal';
-     signalIndex?: number;
- }
-
- export declare function updateIntegralsRelativeValues(spectrum: Entry1D, forceCalculateIntegral?: boolean): void;
-
- export declare function updateRanges(spectrum: Entry1D): void;
-
- export declare function updateRangesRelativeValues(spectrum: Entry1D, forceCalculateIntegral?: boolean): void;
-
- export declare type WindowFunctions = Exponential | SineBell | SineSquare | Traf | Gaussian;
-
- /**
-  * 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>;
-     predicted: Float64Array<ArrayBuffer>;
- };
-
- /**
-  * 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>;
-     predicted: Float64Array<ArrayBuffer>;
- };
-
- export declare interface XreimMultipletAnalysis {
-     analyzer?: AnalizeMultipletOptions;
-     autoPhase?: boolean;
- }
-
- /**
-  * 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(
- /**
-  * Imaginary data is optional for auto phase correction of the region before the analysis.
-  */
- data: DataXReOptionalIm, options?: XreimMultipletAnalysis): any;
-
- export declare function xyAutoPeaksPicking(data: DataXY<Float64Array>, options: OptionsXYAutoPeaksPicking): NMRPeak1DWithShapeID[];
-
- /**
-  * error for default windowSize computation
-  * out in data, all data relative to the computation
-  */
- export declare class XYAutoPeaksPickingWindowSizeError extends Error {
-     data: Record<string, unknown>;
-     constructor(data: Record<string, unknown>);
- }
-
- /**
-  * 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(
- /**
-  * x is the amplitude of the pulse field gradient
-  * y is the exponential decay signal.
-  */
- data: DataXY, options: CalculateDiffussionCoefficientOptions): {
-     regression: DiffusionRegression;
-     coefficient: number;
-     signalAbsenseDiffussion: number;
- };
-
- export declare function xyCalculateT1(data: DataXY, options?: CalculateT1Options): XYCalculateT1Return;
-
- declare interface XYCalculateT1Return {
-     relaxationT1: number;
-     fullMagnetization: number;
-     regression: T1Regression;
- }
-
- export declare function xyGetPivot(data: DataXY<Float64Array>, options?: {
-     thresholdFactor?: number;
-     frequency?: number;
- }): PointXY;
-
- export declare function xyKineticFirstOrder(data: DataXY): {
-     regression: ExponentialRegression;
-     rateConstant: number;
-     initialConcentration: number;
- };
-
- declare interface XYObjectSidePointOptions {
-     minX: number;
-     maxX: number;
-     thresholdFactor?: number;
- }
-
- export declare function xyPeaksOptimization<T extends PeakXYWidth>(data: DataXY, peaks: T[], options: XYPeaksOptimizationOptions): (T extends {
-     id: string;
- } ? GSDPeakOptimizedID : GSDPeakOptimized)[];
-
- export declare interface XYPeaksOptimizationOptions extends OptimizePeaksOptions {
-     /**
-      * frequency to convert width and fwhm to ppm.
-      */
-     frequency: number;
- }
-
- /**
-  * 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<Peak2D & {
-     id: string;
- }>[];
-
- export declare interface XYZAutoSignalsPickingOptions {
-     /**
-      * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
-      * @default 14
-      */
-     sizeToPad?: number;
-     /**
-      * If it's true, try to find the real maximum for each bidimensional peak.
-      * @default true
-      */
-     realTopDetection?: boolean;
-     /**
-      * positive value filter small peaks by intensity
-      * @default 0.5
-      */
-     thresholdFactor?: number;
-     /**
-      * specify the nuclei of each dimension
-      * @default ['1H','1H']
-      */
-     nuclei?: string[];
-     /**
-      * specify the frequency for each dimension.
-      */
-     observedFrequencies: number[] | Float64Array;
-     /**
-      * If it's true, it try to ajust the shift and add missing cross peaks, useful only for homonuclear data.
-      * @default false
-      */
-     enhanceSymmetry?: boolean;
-     /**
-      * If it's true, peaks with less than a specific percentage (maxPercentCutOff) of the maximum intensity will be removed.
-      * @default true;
-      */
-     clean?: boolean;
-     /**
-      * percentage of maximum intensity as cutoff for small peaks.
-      * @default 0.03
-      */
-     maxPercentCutOff?: number;
-     /**
-      * Specify the minimum distance in Hz for each dimension to join peaks in a signal.
-      * @default [24,24]
-      */
-     tolerances?: number[];
-     /**
-      * If it is true, the convolution will be forced by FFT
-      * @default true
-      */
-     convolutionByFFT?: boolean;
-     /**
-      * kernel options to calculate a laplacianOfGaussian kernel with a specify size.
-      */
-     kernel?: GetKernelOptions;
- }
-
- export declare function xyzAutoZonesPicking(spectraData: NmrData2DContent, options: XYZAutoZonesPickingOptions): NMRZoneWithID[];
-
- export declare interface XYZAutoZonesPickingOptions {
-     /**
-      * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
-      * @default 14
-      */
-     sizeToPad?: number;
-     /**
-      * If it's true, try to find the real maximum for each bidimensional peak.
-      * @default true
-      */
-     realTopDetection?: boolean;
-     /**
-      * positive value filter small peaks by intensity
-      * @default 0.5
-      */
-     thresholdFactor?: number;
-     /**
-      * specify the nuclei of each dimension
-      * @default ['1H','1H']
-      */
-     nuclei?: string[];
-     /**
-      * specify the frequency for each dimension.
-      */
-     observedFrequencies: number[] | Float64Array;
-     /**
-      * If it's true, it try to ajust the shift and add missing cross peaks, useful only for homonuclear data.
-      * @default false
-      */
-     enhanceSymmetry?: boolean;
-     /**
-      * If it's true, peaks with less than a specific percentage (maxPercentCutOff) of the maximum intensity will be removed.
-      * @default true;
-      */
-     clean?: boolean;
-     /**
-      * percentage of maximum intensity as cutoff for small peaks.
-      * @default 0.03
-      */
-     maxPercentCutOff?: number;
-     /**
-      * Specify the minimum distance in Hz for each dimension to join peaks in a signal.
-      * @default [24,24]
-      */
-     tolerances?: number[];
-     /**
-      * If it is true, the convolution will be forced by FFT
-      * @default true
-      */
-     convolutionByFFT?: boolean;
-     /**
-      * kernel options to calculate a laplacianOfGaussian kernel with a specify size.
-      */
-     kernel?: GetKernelOptions;
- }
-
- export declare function xyzJResAnalyzer(signals: NMRSignal2D[], options?: XYZJResAnalyzerOptions): NMRZoneWithID[] | (NMRSignal2D<Peak2D> & {
-     id: string;
- })[];
-
- declare interface XYZJResAnalyzerOptions extends CompilePatternOptions {
-     /**
-      * maximum difference in Hz to discard if the signal is symmetric.
-      * @default 0.08
-      */
-     referenceMaxShiftError?: number;
-     /**
-      * reference value in Hz
-      * @default 0
-      */
-     reference?: number;
-     /**
-      * if it is true returns zones instead of signals 2D
-      * @default false
-      */
-     getZones?: boolean;
- }
-
- export declare function xyzPhaseCorrection(data: NmrData2DFt, options: PhaseCorrectionTwoDOptions): NmrData2DFt;
-
- declare type ZeroFilling = FilterFactory<Entry1D, ZeroFillingOptions> & Pick<ZeroFillingFilterOptions, 'name'>;
-
- declare type ZeroFillingDimension1 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension1Options, 'name'>;
-
- declare type ZeroFillingDimension2 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension2Options, 'name'>;
-
- export declare interface Zone2DError {
-     x: number;
-     y: number;
- }
-
-
- export * from "gyromagnetic-ratio";
-
- export { }
+ * 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>;
+    predicted: Float64Array<ArrayBuffer>;
+};
+
+/**
+ * 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>;
+    predicted: Float64Array<ArrayBuffer>;
+};
+
+export declare interface XreimMultipletAnalysis {
+    analyzer?: AnalizeMultipletOptions;
+    autoPhase?: boolean;
+}
+
+/**
+ * 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(
+/**
+ * Imaginary data is optional for auto phase correction of the region before the analysis.
+ */
+data: DataXReOptionalIm, options?: XreimMultipletAnalysis): any;
+
+export declare function xyAutoPeaksPicking(data: DataXY<Float64Array>, options: OptionsXYAutoPeaksPicking): NMRPeak1DWithShapeID[];
+
+/**
+ * error for default windowSize computation
+ * out in data, all data relative to the computation
+ */
+export declare class XYAutoPeaksPickingWindowSizeError extends Error {
+    data: Record<string, unknown>;
+    constructor(data: Record<string, unknown>);
+}
+
+/**
+ * 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(
+/**
+ * x is the amplitude of the pulse field gradient
+ * y is the exponential decay signal.
+ */
+data: DataXY, options: CalculateDiffussionCoefficientOptions): {
+    regression: DiffusionRegression;
+    coefficient: number;
+    signalAbsenseDiffussion: number;
+};
+
+export declare function xyCalculateT1(data: DataXY, options?: CalculateT1Options): XYCalculateT1Return;
+
+declare interface XYCalculateT1Return {
+    relaxationT1: number;
+    fullMagnetization: number;
+    regression: T1Regression;
+}
+
+export declare function xyGetPivot(data: DataXY<Float64Array>, options?: {
+    thresholdFactor?: number;
+    frequency?: number;
+}): PointXY;
+
+export declare function xyKineticFirstOrder(data: DataXY): {
+    regression: ExponentialRegression;
+    rateConstant: number;
+    initialConcentration: number;
+};
+
+declare interface XYObjectSidePointOptions {
+    minX: number;
+    maxX: number;
+    thresholdFactor?: number;
+}
+
+export declare function xyPeaksOptimization<T extends PeakXYWidth>(data: DataXY, peaks: T[], options: XYPeaksOptimizationOptions): (T extends {
+    id: string;
+} ? GSDPeakOptimizedID : GSDPeakOptimized)[];
+
+export declare interface XYPeaksOptimizationOptions extends OptimizePeaksOptions {
+    /**
+     * frequency to convert width and fwhm to ppm.
+     */
+    frequency: number;
+}
+
+/**
+ * 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<Peak2D & {
+    id: string;
+}>[];
+
+export declare interface XYZAutoSignalsPickingOptions {
+    /**
+     * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
+     * @default 14
+     */
+    sizeToPad?: number;
+    /**
+     * If it's true, try to find the real maximum for each bidimensional peak.
+     * @default true
+     */
+    realTopDetection?: boolean;
+    /**
+     * positive value filter small peaks by intensity
+     * @default 0.5
+     */
+    thresholdFactor?: number;
+    /**
+     * specify the nuclei of each dimension
+     * @default ['1H','1H']
+     */
+    nuclei?: string[];
+    /**
+     * specify the frequency for each dimension.
+     */
+    observedFrequencies: number[] | Float64Array;
+    /**
+     * If it's true, it try to ajust the shift and add missing cross peaks, useful only for homonuclear data.
+     * @default false
+     */
+    enhanceSymmetry?: boolean;
+    /**
+     * If it's true, peaks with less than a specific percentage (maxPercentCutOff) of the maximum intensity will be removed.
+     * @default true;
+     */
+    clean?: boolean;
+    /**
+     * percentage of maximum intensity as cutoff for small peaks.
+     * @default 0.03
+     */
+    maxPercentCutOff?: number;
+    /**
+     * Specify the minimum distance in Hz for each dimension to join peaks in a signal.
+     * @default [24,24]
+     */
+    tolerances?: number[];
+    /**
+     * If it is true, the convolution will be forced by FFT
+     * @default true
+     */
+    convolutionByFFT?: boolean;
+    /**
+     * kernel options to calculate a laplacianOfGaussian kernel with a specify size.
+     */
+    kernel?: GetKernelOptions;
+}
+
+export declare function xyzAutoZonesPicking(spectraData: NmrData2DContent, options: XYZAutoZonesPickingOptions): NMRZoneWithID[];
+
+export declare interface XYZAutoZonesPickingOptions {
+    /**
+     * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
+     * @default 14
+     */
+    sizeToPad?: number;
+    /**
+     * If it's true, try to find the real maximum for each bidimensional peak.
+     * @default true
+     */
+    realTopDetection?: boolean;
+    /**
+     * positive value filter small peaks by intensity
+     * @default 0.5
+     */
+    thresholdFactor?: number;
+    /**
+     * specify the nuclei of each dimension
+     * @default ['1H','1H']
+     */
+    nuclei?: string[];
+    /**
+     * specify the frequency for each dimension.
+     */
+    observedFrequencies: number[] | Float64Array;
+    /**
+     * If it's true, it try to ajust the shift and add missing cross peaks, useful only for homonuclear data.
+     * @default false
+     */
+    enhanceSymmetry?: boolean;
+    /**
+     * If it's true, peaks with less than a specific percentage (maxPercentCutOff) of the maximum intensity will be removed.
+     * @default true;
+     */
+    clean?: boolean;
+    /**
+     * percentage of maximum intensity as cutoff for small peaks.
+     * @default 0.03
+     */
+    maxPercentCutOff?: number;
+    /**
+     * Specify the minimum distance in Hz for each dimension to join peaks in a signal.
+     * @default [24,24]
+     */
+    tolerances?: number[];
+    /**
+     * If it is true, the convolution will be forced by FFT
+     * @default true
+     */
+    convolutionByFFT?: boolean;
+    /**
+     * kernel options to calculate a laplacianOfGaussian kernel with a specify size.
+     */
+    kernel?: GetKernelOptions;
+}
+
+export declare function xyzJResAnalyzer(signals: NMRSignal2D[], options?: XYZJResAnalyzerOptions): NMRZoneWithID[] | (NMRSignal2D<Peak2D> & {
+    id: string;
+})[];
+
+declare interface XYZJResAnalyzerOptions extends CompilePatternOptions {
+    /**
+     * maximum difference in Hz to discard if the signal is symmetric.
+     * @default 0.08
+     */
+    referenceMaxShiftError?: number;
+    /**
+     * reference value in Hz
+     * @default 0
+     */
+    reference?: number;
+    /**
+     * if it is true returns zones instead of signals 2D
+     * @default false
+     */
+    getZones?: boolean;
+}
+
+export declare function xyzPhaseCorrection(data: NmrData2DFt, options: PhaseCorrectionTwoDOptions): NmrData2DFt;
+
+declare type ZeroFilling = FilterFactory<Entry1D, ZeroFillingOptions> & Pick<ZeroFillingFilterOptions, 'name'>;
+
+declare type ZeroFillingDimension1 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension1Options, 'name'>;
+
+declare type ZeroFillingDimension2 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension2Options, 'name'>;
+
+export declare interface Zone2DError {
+    x: number;
+    y: number;
+}
+
+
+export * from "gyromagnetic-ratio";
+
+export { }