nmr-processing 18.0.2 → 19.0.0

package/dist/nmr-processing.d.ts

@@ -1,84 +1,124 @@
 import type { AnalizeMultipletOptions } from 'multiplet-analysis';
-import { AtomMapping } from './ctMolfileParser';
+import type { Apodization1DFilterOptions } from '@zakodium/nmr-types';
+import type { Apodization1DOptions } from '@zakodium/nmr-types';
+import type { Apodization2D1Options } from '@zakodium/nmr-types';
+import type { Apodization2D2Options } from '@zakodium/nmr-types';
+import type { ApodizationDimension1Options } from '@zakodium/nmr-types';
+import type { ApodizationDimension2Options } from '@zakodium/nmr-types';
+import type { AutoPhaseCorrection2D } from '@zakodium/nmr-types';
+import type { BackwardLinearPredictionFilterOptions } from '@zakodium/nmr-types';
+import type { BackwardLPDimension1Options } from '@zakodium/nmr-types';
+import type { BackwardLPDimension2Options } from '@zakodium/nmr-types';
+import type { BackwardLPOptions } from '@zakodium/nmr-types';
+import type { BaselineCorrection2DFilterOptions } from '@zakodium/nmr-types';
+import type { BaselineCorrectionFilterOptions } from '@zakodium/nmr-types';
+import type { BaselineCorrectionOptions } from '@zakodium/nmr-types';
+import type { BaselineCorrectionZone } from '@zakodium/nmr-types';
 import { BaseRegression } from 'ml-regression-base';
-import { CTSignal } from './ctCreateSignals';
 import type { DataReIm } from 'ml-spectra-processing';
 import type { DataXReIm } from 'ml-spectra-processing';
 import { DataXY } from 'cheminfo-types';
+import type { DigitalFilter2DOptions } from '@zakodium/nmr-types';
+import type { DigitalFilterOption } from '@zakodium/nmr-types';
+import type { DirectDimensionOptions } from '@zakodium/nmr-types';
+import type { DirectOptions } from 'ml-direct';
 import type { DoubleArray } from 'cheminfo-types';
+import type { EquallySpacedOptions } from '@zakodium/nmr-types';
+import type { ExclusionZonesOptions } from '@zakodium/nmr-types';
+import type { ExponentialOptions } from '@zakodium/nmr-types';
 import { ExponentialRegression } from 'ml-regression-exponential';
-import type { FilterXYType } from 'ml-signal-processing';
+import type { FFT1DOptions } from '@zakodium/nmr-types';
+import type { FFTDimension1Options } from '@zakodium/nmr-types';
+import type { FFTDimension2Options } from '@zakodium/nmr-types';
+import type { Filter1DEntry } from '@zakodium/nmr-types';
+import type { Filter1DOptions } from '@zakodium/nmr-types';
+import type { Filter2DEntry } from '@zakodium/nmr-types';
+import type { Filter2DOptions } from '@zakodium/nmr-types';
+import * as Filters from 'ml-signal-processing';
+import type { FordwardLPDimension1Options } from '@zakodium/nmr-types';
+import type { FordwardLPDimension2Options } from '@zakodium/nmr-types';
+import type { ForwardLP1DOptions } from '@zakodium/nmr-types';
+import type { ForwardLPOptions } from '@zakodium/nmr-types';
 import { FromTo } from 'cheminfo-types';
+import type { GaussianOptions } from '@zakodium/nmr-types';
+import { GeneralAssignment as GeneralAssignment_2 } from './utils/generalAssignment/buildAssignments.js';
 import type { GenerateSpectrumOptions } from 'spectrum-generator';
 import type { GroupedDiaID } from 'openchemlib-utils';
 import type { GSDOptions } from 'ml-gsd';
 import { GSDPeakOptimized } from 'ml-gsd';
 import { GSDPeakOptimizedID } from 'ml-gsd';
-import { Jcoupling as Jcoupling_2 } from './Jcoupling';
+import type { IndirectDimensionOptions } from '@zakodium/nmr-types';
+import type { Info1D } from '@zakodium/nmr-types';
+import type { Info2D } from '@zakodium/nmr-types';
+import type { Integral } from '@zakodium/nmr-types';
+import type { Integrals } from '@zakodium/nmr-types';
+import { Jcoupling } from '@zakodium/nmr-types';
 import type { JoinBroadPeaksOptions } from 'ml-gsd';
-import { LightLogger } from 'cheminfo-types';
+import type { LevenbergMarquardtOptions } from 'ml-levenberg-marquardt';
+import type { LightLogger } from 'cheminfo-types';
 import type { Logger } from 'cheminfo-types';
-import { MatchingMultiplicity as MatchingMultiplicity_2 } from '..';
+import { MatchingMultiplicity as MatchingMultiplicity_2 } from '../index.js';
 import { Matrix } from 'ml-matrix';
+import type { MatrixOptions } from '@zakodium/nmr-types';
 import type { Molecule } from 'openchemlib';
 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 { NMRRange as NMRRange_2 } from './NMRRange';
+import type { NMRPeak1D } from '@zakodium/nmr-types';
+import { NMRRange } from '@zakodium/nmr-types';
+import type { NMRSignal1D } from '@zakodium/nmr-types';
+import { NMRZoneWithID as NMRZoneWithID_2 } from './xyzAutoZonesPicking.js';
 import type { NumberArray } from 'cheminfo-types';
+import type { NUSDimension2Options } from '@zakodium/nmr-types';
 import type { OCLMolecule } from 'cheminfo-types';
-import { OneLetterMultiplet as OneLetterMultiplet_2 } from './MultiplicityPatterns';
+import { OneDimensionalAssignment as OneDimensionalAssignment_2 } from './utils/oneDimensionalAssignment/buildAssignments.js';
+import { OneDimensionalAssignment as OneDimensionalAssignment_3 } from '../index.js';
+import { OneLetterMultiplet as OneLetterMultiplet_2 } from './MultiplicityPatterns.js';
 import type { OptimizePeaksOptions } from 'ml-gsd';
 import type { OptionsSG1D } from 'spectrum-generator';
-import { ParsedCoupling } from './ctJSONParser';
-import { ParsedShift } from './ctJSONParser';
-import type { Peak2D as Peak2D_2 } from 'ml-matrix-peaks-finder';
+import type { Peak1D } from '@zakodium/nmr-types';
+import { Peak2D } from 'ml-matrix-peaks-finder';
+import type { Peaks } from '@zakodium/nmr-types';
 import type { PeakXYWidth } from 'cheminfo-types';
+import type { PhaseCorrection1DFilterOptions } from '@zakodium/nmr-types';
+import type { PhaseCorrection1DOptions } from '@zakodium/nmr-types';
+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 as Range_2 } from '@zakodium/nmr-types';
+import type { Ranges } from '@zakodium/nmr-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
-import { SpectraDataWithIds as SpectraDataWithIds_2 } from './nmrAssigment';
+import type { Shapes } from '@zakodium/nmr-types';
+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 type { SignalProcessingFilter } from '@zakodium/nmr-types';
+import type { SineBellOptions } from '@zakodium/nmr-types';
+import type { SymmetrizeCosyLikeOptions } from '@zakodium/nmr-types';
 import type { TopicMolecule } from 'openchemlib-utils';
+import type { TrafOptions } from '@zakodium/nmr-types';
 import type { XDistributionStats } from 'ml-spectra-processing';
 import type { XRobustDistributionStats } from 'ml-spectra-processing';
-import type { XYEquallySpacedOptions } from 'ml-spectra-processing';
 import type { XYNumber } from 'spectrum-generator';
+import type { ZeroFillingDimension1Options } from '@zakodium/nmr-types';
+import type { ZeroFillingDimension2Options } from '@zakodium/nmr-types';
+import type { ZeroFillingFilterOptions } from '@zakodium/nmr-types';
+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_2): void;
 
-export declare interface AirplsOptions {
-    zones: BaselineCorrectionZone[];
-    algorithm: 'airpls';
-    maxIterations: number;
-    tolerance: number;
-}
+declare type Apodization1D = FilterFactory<Entry1D, Apodization1DOptions> & Pick<Apodization1DFilterOptions, 'name'>;
 
-declare type Apodization1D = FilterFactory<Entry1D, Apodization2DOptions> & Pick<Apodization1DFilterOptions, 'name'>;
+declare type ApodizationDimension1 = FilterFactory<Entry2D, Apodization2D1Options> & Pick<ApodizationDimension1Options, 'name'>;
 
-declare interface Apodization1DFilterOptions extends BaseFilter {
-    name: 'apodization';
-    value: Apodization2DOptions;
-}
+declare type ApodizationDimension2 = FilterFactory<Entry2D, Apodization2D2Options> & Pick<ApodizationDimension2Options, 'name'>;
 
-declare type Apodization2DOptions = Shapes;
-export { Apodization2DOptions as Apodization1DOptions }
-export { Apodization2DOptions }
-
-declare type ApodizationDimension1 = FilterFactory<Entry2D, Apodization2DOptions> & Pick<ApodizationDimension1Options, 'name'>;
-
-declare interface ApodizationDimension1Options extends BaseFilter {
-    name: 'apodizationDimension1';
-    value: Apodization2DOptions;
-}
-
-declare type ApodizationDimension2 = FilterFactory<Entry2D, Apodization2DOptions> & Pick<ApodizationDimension2Options, 'name'>;
-
-declare interface ApodizationDimension2Options extends BaseFilter {
-    name: 'apodizationDimension2';
-    value: Apodization2DOptions;
-}
-
-export declare function apodizationXReIm(data: Required<NmrData1D>, options: Apodization2DOptions): {
+export declare function apodizationXReIm(data: Required<NmrData1D>, options: Apodization1DOptions): {
     x: Float64Array<ArrayBufferLike>;
     re: Float64Array<ArrayBufferLike>;
     im: Float64Array<ArrayBufferLike>;
@@ -137,6 +177,8 @@ export declare interface ApplyWindowOptions {
     output?: DoubleArray;
 }
 
+declare type Atom = ReturnType<typeof getAtoms>[0];
+
 declare interface AtomInput {
     id: ID;
     pid: ID;
@@ -157,12 +199,30 @@ declare interface AtomInput {
     s: ID | null;
 }
 
-declare type AtomTypes = 'H' | 'C';
-
-export declare interface AutoPhaseCorrection2D {
-    threshold?: number;
+declare interface AtomOutput {
+    id: ID;
+    parentID: ID;
+    name: string;
+    remarks: string;
+    nucleusType: NucleusType;
+    cipRank: {
+        canonical: number;
+        rd: number;
+        nmr: number;
+    };
+    ordinal: number;
+    stereochemistryFlags: number[];
+    spinSystemFlags: number[];
+    formalcharge: number;
+    partialCharge: number;
+    coordinates2D: [number, number, number];
+    coordinates3D: [number, number, number];
+    parent2D: string | null;
+    shift: ID | null;
 }
 
+declare type AtomTypes = 'H' | 'C';
+
 export declare interface AutoPhaseCorrectionOptions {
     minRegSize?: number;
     maxDistanceToJoin?: number;
@@ -173,84 +233,14 @@ export declare interface AutoPhaseCorrectionOptions {
 
 declare type BackwardLinearPrediction1D = FilterFactory<Entry1D, Partial<BackwardLPOptions>> & Pick<BackwardLinearPredictionFilterOptions, 'name'>;
 
-declare interface BackwardLinearPredictionFilterOptions extends BaseFilter {
-    name: 'backwardLinearPrediction';
-    value: Partial<BackwardLPOptions>;
-}
-
 declare type BackwardLPDimension1 = FilterFactory<Entry2D, Partial<BackwardLPOptions>> & Pick<BackwardLPDimension1Options, 'name'>;
 
-declare interface BackwardLPDimension1Options extends BaseFilter {
-    name: 'blpDimension1';
-    value: Partial<BackwardLPOptions>;
-}
-
 declare type BackwardLPDimension2 = FilterFactory<Entry2D, Partial<BackwardLPOptions>> & Pick<BackwardLPDimension2Options, 'name'>;
 
-declare interface BackwardLPDimension2Options extends BaseFilter {
-    name: 'blpDimension2';
-    value: Partial<BackwardLPOptions>;
-}
-
-export declare interface BackwardLPOptions {
-    /**
-     * Number of coefficients to be calculated in the SVD.
-     */
-    nbCoefficients: number;
-    /**
-     * Number of points used in the prediction.
-     */
-    nbInputs: number;
-    /**
-     * Number of points to predict
-     */
-    nbPoints: number;
-    /**
-     * Output array that could be used for in-place modification.
-     */
-    output?: Float64Array;
-}
-
-declare interface BaseField {
-    key: string;
-    level: number;
-    name: string;
-    description: string;
-}
-
-declare interface BaseFilter {
-    enabled?: boolean;
-}
-
-declare interface BaseFilterEntry extends Required<BaseFilter> {
-    id?: string;
-    error?: string;
-}
-
-export declare type BaselineAlgorithms = 'airpls' | 'polynomial';
-
 declare type BaselineCorrection1D = FilterFactory<Entry1D, BaselineCorrectionOptions> & Pick<BaselineCorrectionFilterOptions, 'name'>;
 
 declare type BaselineCorrection2D = FilterFactory<Entry2D, Record<string, never>> & Pick<BaselineCorrection2DFilterOptions, 'name'>;
 
-declare interface BaselineCorrection2DFilterOptions extends BaseFilter {
-    name: 'baselineCorrectionTwoDimensions';
-    value: Record<string, never>;
-}
-
-declare interface BaselineCorrectionFilterOptions extends BaseFilter {
-    name: 'baselineCorrection';
-    value: BaselineCorrectionOptions;
-}
-
-export declare type BaselineCorrectionOptions = PolynomialOptions | AirplsOptions;
-
-export declare interface BaselineCorrectionZone {
-    from: number;
-    to: number;
-    id: string;
-}
-
 export declare interface BaselineZoneOptions {
     /**
      * The width factor to use to enlarge the peaks width
@@ -286,10 +276,6 @@ declare interface BaselineZoneOptionsDietrich extends BaselineZoneOptions {
     maxDistanceToJoin?: number;
 }
 
-declare interface BasePeak {
-    id: string;
-}
-
 declare interface BondInput {
     id: ID;
     b: number;
@@ -298,8 +284,12 @@ declare interface BondInput {
     a: [ID, ID];
 }
 
-declare interface BooleanField extends Field<boolean> {
-    type: 'boolean';
+declare interface BondOutput {
+    id: ID;
+    bondType: string;
+    stereochemistryFlags: number[];
+    spinSystemFlags: number[];
+    atoms: [ID, ID];
 }
 
 declare type CacheResult = EmptyValue | PredictionBase1D | Promise<EmptyValue | PredictionBase1D>;
@@ -320,7 +310,12 @@ export declare interface CalculateDiffussionCoefficientOptions {
 }
 
 declare interface CalculateT1Options {
-    optimization?: any;
+    optimization?: CalculateT1OptionsOptimization;
+}
+
+declare interface CalculateT1OptionsOptimization {
+    shapeFunc?: (parameters: number[]) => (x: number) => number;
+    options?: Partial<LevenbergMarquardtOptionsDefault> & LevenbergMarquardtOptionsOverride;
 }
 
 export declare const carbonImpurities: DatabaseNMREntry[];
@@ -338,8 +333,6 @@ declare function checkRangeKind(range: Range_2): boolean;
 
 declare function checkSignalKinds(range: Range_2, kinds: string[]): boolean;
 
-declare type CommonField = SelectField | StringField | NumberField | BooleanField | LabelField;
-
 declare interface CompilePatternOptions {
     observedFrequencies?: number[] | Float64Array;
     tolerances?: number[] | Float64Array;
@@ -402,6 +395,29 @@ export declare interface CreateSignals2DOptions {
     maxX: number;
 }
 
+declare interface CTJSONConverterOutput {
+    molarFraction: {
+        value: number;
+        low: number;
+        high: number;
+    };
+    fieldStrength: number;
+    baseItensity: number;
+    intensityLimit: number;
+    spinSystemFlags: number[];
+    spinSystemType: string;
+    analysisType: number;
+    inchiKey: string;
+    populations: ReturnType<typeof getPopulations>;
+    lineShapes: ReturnType<typeof getLineShapes>;
+    shiftGroups: ReturnType<typeof getShiftGroups>;
+    shifts: ReturnType<typeof getShifts>;
+    couplingGroups: ReturnType<typeof getCouplingGroups>;
+    couplings: ReturnType<typeof getCouplings>;
+    atoms: ReturnType<typeof getAtoms>;
+    bonds: ReturnType<typeof getBonds>;
+}
+
 declare interface CTJSONInput {
     v: number;
     vl: number;
@@ -423,6 +439,19 @@ declare interface CTJSONInput {
     b: BondInput[];
 }
 
+declare interface CTParserResult extends Omit<CTJSONConverterOutput, 'shifts' | 'couplings'> {
+    shifts: ParsedShift[];
+    couplings: ParsedCoupling[];
+}
+
+declare interface CTSignal {
+    delta: number;
+    diaIDs: string[];
+    js: Jcoupling[];
+    nbAtoms: number;
+    atoms: number[];
+}
+
 export declare type DataBaseLevelEntry = number | [number] | [number, number, number, number | null, number] | undefined | XDistributionStats;
 
 export declare type DataBaseLevelStructure = Record<string, DataBaseLevelEntry>;
@@ -464,6 +493,22 @@ export declare const DatumKind: {
 
 export declare const default1DApodization: Shapes;
 
+declare const defaultDirectOptimizationOptions: {
+    iterations: number;
+};
+
+declare const defaultLMOptimizationOptions: {
+    damping: number;
+    maxIterations: number;
+    errorTolerance: number;
+};
+
+declare const defaultLMOptimizationOptions_2: {
+    damping: number;
+    maxIterations: number;
+    errorTolerance: number;
+};
+
 declare function deleteFilter(datum: Entry1D, id?: string, logger?: Logger): void;
 
 declare function deleteFilter_2(datum: Entry2D, id?: string, logger?: Logger): void;
@@ -482,30 +527,17 @@ declare type DigitalFilter = FilterFactory<Entry1D, DigitalFilterOptions> & Pick
 
 declare type DigitalFilter2D = FilterFactory<Entry2D, DigitalFilterOptions_2> & Pick<DigitalFilter2DOptions, 'name'>;
 
-declare interface DigitalFilter2DOptions extends BaseFilter {
-    name: 'digitalFilter2D';
-    value: DigitalFilterOptions_2;
-}
-
-declare interface DigitalFilterOption extends BaseFilter {
-    name: 'digitalFilter';
-    value: DigitalFilterOptions;
-}
+declare type DigitalFilterOptions = DigitalFilterOption['value'];
 
-declare interface DigitalFilterOptions {
-    digitalFilterValue: number;
-}
+declare type DigitalFilterOptions_2 = DigitalFilter2DOptions['value'];
 
-declare interface DigitalFilterOptions_2 {
-    digitalFilterValue?: number;
+declare interface DirectOptimizationOptions extends DirectOptions {
+    directOptions?: DirectOptions;
+    minValues: ArrayLike<number>;
+    maxValues: ArrayLike<number>;
 }
 
-export declare interface DirectDimensionOptions {
-    acquisitionScheme?: string;
-    reverse?: boolean;
-    digitalFilterValue?: number;
-    phaseCorrection?: PhaseCorrection;
-}
+declare type DirectOptimizationOptionsDefaultsKeys = Extract<'minValues' | 'maxValues' | 'initialValues' | 'gradientDifference' | keyof typeof defaultDirectOptimizationOptions, keyof DirectOptimizationOptions>;
 
 declare type EmptyValue = void | undefined | null;
 
@@ -548,63 +580,23 @@ declare interface Entry2D<T extends NmrData2D = NmrData2D> {
 
 declare type EquallySpaced = FilterFactory<Entry1D, EquallySpacedFilterOptions> & Pick<EquallySpacedOptions, 'name'>;
 
-declare type EquallySpacedFilterOptions = Pick<XYEquallySpacedOptions, 'from' | 'to' | 'numberOfPoints' | 'exclusions'>;
-
-declare interface EquallySpacedOptions extends BaseFilter {
-    name: 'equallySpaced';
-    value: EquallySpacedFilterOptions;
-}
-
-declare interface ExclusionZone {
-    id: string;
-    from: number;
-    to: number;
-}
+declare type EquallySpacedFilterOptions = EquallySpacedOptions['value'];
 
 declare type ExclusionZones = FilterFactory<Entry1D, ExclusionZonesFilterOptions[]> & Pick<ExclusionZonesOptions, 'name'>;
 
-declare interface ExclusionZonesFilterOptions extends FromTo {
-    id: string;
-}
-
-declare interface ExclusionZonesOptions extends BaseFilter {
-    name: 'exclusionZones';
-    value: ExclusionZonesFilterOptions[];
-}
+declare type ExclusionZonesFilterOptions = ExclusionZonesOptions['value'][number];
 
 declare interface Exponential<ShapeOption = ExponentialOptions> {
     kind: 'exponential';
     options: ShapeOption;
 }
 
-declare interface ExponentialOptions {
-    /**
-     * line broadening value in Hz, a negative value will invert the shape
-     */
-    lineBroadening: number;
-}
-
 declare type FFT1D = FilterFactory<Entry1D, Record<string, never>> & Pick<FFT1DOptions, 'name'>;
 
-declare interface FFT1DOptions extends BaseFilter {
-    name: 'fft';
-    value: Record<string, never>;
-}
-
 declare type FFTDimension1 = FilterFactory<Entry2D, DirectDimensionOptions> & Pick<FFTDimension1Options, 'name'>;
 
-declare interface FFTDimension1Options extends BaseFilter {
-    name: 'fftDimension1';
-    value: DirectDimensionOptions;
-}
-
 declare type FFTDimension2 = FilterFactory<Entry2D, IndirectDimensionOptions> & Pick<FFTDimension2Options, 'name'>;
 
-declare interface FFTDimension2Options extends BaseFilter {
-    name: 'fftDimension2';
-    value: IndirectDimensionOptions;
-}
-
 export declare function fftDirectDimension(data: {
     re: DoubleArray[];
     im: DoubleArray[];
@@ -618,22 +610,10 @@ export declare function fftIndirectDimension(data: {
     im: DoubleArray[] | Matrix;
 }, options: IndirectDimensionOptions): Record<string, Matrix>;
 
-declare interface Field<T> extends BaseField {
-    default: T;
-}
-
 export declare type Filter1D = FFT1D | BaselineCorrection1D | BackwardLinearPrediction1D | Apodization1D | DigitalFilter | EquallySpaced | ExclusionZones | ForwardLP1D | PhaseCorrection1D | ShiftX | SignalProcessing | ZeroFilling;
 
-export declare type Filter1DEntry = Filter1DOptions & BaseFilterEntry;
-
-export declare type Filter1DOptions = BaselineCorrectionFilterOptions | FFT1DOptions | ZeroFillingFilterOptions | SignalProcessingFilter | ShiftXFilterOptions | PhaseCorrection1DFilterOptions | ForwardLP1DOptions | ExclusionZonesOptions | EquallySpacedOptions | DigitalFilterOption | Apodization1DFilterOptions | BackwardLinearPredictionFilterOptions;
-
 export declare type Filter2D = ApodizationDimension1 | ApodizationDimension2 | BaselineCorrection2D | BackwardLPDimension1 | BackwardLPDimension2 | NUSDimension2 | FFTDimension1 | FFTDimension2 | FordwardLPDimension1 | FordwardLPDimension2 | DigitalFilter2D | PhaseCorrection2D | ZeroFillingDimension1 | ZeroFillingDimension2 | SymmetrizeCosyLike | Shift2DX | Shift2DY;
 
-export declare type Filter2DEntry = Filter2DOptions & BaseFilterEntry;
-
-export declare type Filter2DOptions = ApodizationDimension1Options | ApodizationDimension2Options | BaselineCorrection2DFilterOptions | BackwardLPDimension1Options | BackwardLPDimension2Options | DigitalFilter2DOptions | FFTDimension1Options | NUSDimension2Options | FFTDimension2Options | FordwardLPDimension1Options | FordwardLPDimension2Options | PhaseCorrection2DOptions | Shift2DXFilterOptions | Shift2DYFilterOptions | SymmetrizeCosyLikeOptions | ZeroFillingDimension1Options | ZeroFillingDimension2Options;
-
 export declare interface FilterDomainUpdateRules {
     updateYDomain: boolean;
     updateXDomain: boolean;
@@ -664,6 +644,10 @@ declare interface FilterFactory<EntryType, OptionsType> {
     domainUpdateRules: Readonly<FilterDomainUpdateRules>;
 }
 
+declare type FilterFunction = Extract<FilterSymbols, Function>;
+
+declare type FilterOptions = Extract<Parameters<FilterFunction>[1], object>;
+
 export declare const Filters1D: {
     [K in Filter1D['name']]: Extract<Filter1D, {
         name: K;
@@ -696,6 +680,8 @@ export declare namespace Filters2DManager {
     }
 }
 
+declare type FilterSymbols = (typeof Filters)[keyof typeof Filters];
+
 /**
  * Look for a multiplet based on the pattern name or abbreviation.
  * @param name - pattern name or abbreviation.
@@ -715,64 +701,21 @@ export declare function findPivot(peaks: PointXY[], options: XYObjectSidePointOp
 
 declare type FordwardLPDimension1 = FilterFactory<Entry2D, Partial<BackwardLPOptions>> & Pick<FordwardLPDimension1Options, 'name'>;
 
-declare interface FordwardLPDimension1Options extends BaseFilter {
-    name: 'flpDimension1';
-    value: Partial<BackwardLPOptions>;
-}
-
 declare type FordwardLPDimension2 = FilterFactory<Entry2D, Partial<BackwardLPOptions>> & Pick<FordwardLPDimension2Options, 'name'>;
 
-declare interface FordwardLPDimension2Options extends BaseFilter {
-    name: 'flpDimension2';
-    value: Partial<BackwardLPOptions>;
-}
-
 declare type ForwardLP1D = FilterFactory<Entry1D, Partial<ForwardLPOptions>> & Pick<ForwardLP1DOptions, 'name'>;
 
-declare interface ForwardLP1DOptions extends BaseFilter {
-    name: 'forwardLinearPrediction';
-    value: Partial<ForwardLPOptions>;
-}
-
-export declare interface ForwardLPOptions {
-    /**
-     * Number of coefficients to be calculated in the SVD.
-     */
-    nbCoefficients: number;
-    /**
-     * Number of points used in the prediction.
-     */
-    nbInputs: number;
-    /**
-     * Number of points to predict
-     */
-    nbPoints: number;
-    /**
-     * Output array that could be used for in-place modification.
-     */
-    output?: Float64Array;
-}
-
 declare interface Gaussian<ShapeOption = GaussianOptions> {
     kind: 'gaussian';
     options: ShapeOption;
 }
 
-declare interface GaussianOptions {
-    /**
-     * Inverse Exponential Width, Hz
-     */
-    lineBroadening: number;
-    /**
-     * Location of Gauss Maximum, this value should be between 0 to 1
-     */
-    lineBroadeningCenter: number;
+export declare interface GeneralAssignment {
+    score: number;
+    assignment: SpectraDataWithIds[];
 }
 
-export declare function get13CAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get13CAssignmentsOptions): Promise<{
-    score: any;
-    assignment: NMRRangeWithIntegration[];
-}[]>;
+export declare function get13CAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get13CAssignmentsOptions): Promise<OneDimensionalAssignment_3[]>;
 
 export declare interface Get13CAssignmentsOptions {
     restrictionByCS?: Partial<RestrictionByCS1D>;
@@ -804,10 +747,7 @@ export declare interface Get13CAssignmentsOptions {
 
 export declare function get1DErrorFactor(spectrum: Entry1D): number;
 
-export declare function get1HAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get1HAssignmentsOptions): Promise<{
-    score: any;
-    assignment: NMRRangeWithIntegration[];
-}[]>;
+export declare function get1HAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get1HAssignmentsOptions): Promise<OneDimensionalAssignment_2[]>;
 
 export declare interface Get1HAssignmentsOptions {
     restrictionByCS?: Partial<RestrictionByCS1D>;
@@ -839,10 +779,7 @@ export declare interface Get1HAssignmentsOptions {
 
 export declare function get2DErrorFactor(spectrum: Entry2D): Zone2DError;
 
-export declare function getAssignments(input: GetAutoAssignmentInput, options?: GetAssignmentsOptions): Promise<{
-    score: any;
-    assignment: SpectraDataWithIds_2[];
-}[]>;
+export declare function getAssignments(input: GetAutoAssignmentInput, options?: GetAssignmentsOptions): Promise<GeneralAssignment_2[]>;
 
 export declare interface GetAssignmentsOptions {
     justAssign?: AtomTypes[][];
@@ -889,6 +826,8 @@ export declare interface GetAssignmentsOptions {
     };
 }
 
+declare function getAtoms(a: AtomInput[]): AtomOutput[];
+
 export declare interface GetAutoAssignmentInput {
     spectra: SpectraData[];
     /**
@@ -914,6 +853,34 @@ export declare function getBaselineZones(data: NmrData1D, options?: BaselineZone
  */
 export declare function getBaselineZonesByDietrich(data: NmrData1D, options?: BaselineZoneOptionsDietrich): BaselineCorrectionZone[];
 
+declare function getBonds(b: BondInput[]): BondOutput[];
+
+declare function getCouplingGroups(cg: CouplingGroupInput[]): {
+    id: string;
+    parentID: string;
+    name: string;
+    remarks: string;
+    coupling: {
+        value: number;
+        low: number;
+        high: number;
+    };
+    spinSystemFlags: number[];
+    couplingType: string;
+}[];
+
+declare function getCouplings(c: CouplingInput[]): {
+    id: string;
+    parentID: string;
+    name: string;
+    remarks: string;
+    couplingGroup: string;
+    shifts: {
+        from: string;
+        to: string;
+    };
+}[];
+
 export declare function getDatabase(url?: string, options?: {
     /**
      * @default 'tsv'
@@ -940,6 +907,8 @@ declare interface GetKernelOptions {
     yLength?: number;
 }
 
+declare function getLineShapes(l: LineShapeData[]): LineShapeResult[];
+
 declare function getNbAtoms(range: Range_2, signalIndex?: number): number;
 
 export declare function getPeakDelta(peak: Peak1D | NMRPeak1D, shiftTarget: ShiftTarget, shift: number): {
@@ -964,6 +933,36 @@ export declare interface GetPeakListOptions extends GSDOptions, OptimizePeaksOpt
     maxAbsDdY?: number;
 }
 
+declare function getPopulations(p: PopulationInput[]): PopulationOutput[];
+
+declare function getShiftGroups(sg: ShiftGroupEntry[]): {
+    id: string;
+    parentID: string;
+    name: string;
+    remarks: string;
+    shift: {
+        value: number;
+        low: number;
+        high: number;
+    };
+    spin2: number;
+    spinCount: number;
+    exchangeable: boolean;
+    spinSystemFlags: number[];
+    gamma: number;
+    iterationWeight: number;
+    response: {
+        value: number;
+        low: number;
+        high: number;
+        sf: number[];
+    };
+    population: string;
+    lineShape: string;
+}[];
+
+declare function getShifts(s: ShiftInput[]): ShiftOutput[];
+
 export declare function getShiftX(spectrum: Entry1D): number;
 
 declare interface HOSEPrediction {
@@ -991,82 +990,6 @@ export declare interface ImpuritySignal {
     shift: number;
 }
 
-export declare interface IndirectDimensionOptions {
-    acquisitionScheme?: string;
-    reverse?: boolean;
-    phaseCorrection?: PhaseCorrection_2;
-}
-
-declare interface Info {
-    owner?: string;
-    isFid: boolean;
-    date?: string;
-    localeDate?: string;
-    epoch?: number;
-    phc1?: number;
-    phc0?: number;
-    aqMod?: number;
-    isComplex: boolean;
-    dimension: number;
-    isFt: boolean;
-    experiment?: any;
-    digitalFilter?: number;
-    experimentNumber?: number;
-    solvent?: string;
-    pulseSequence?: string;
-    name: string;
-}
-
-export declare interface Info1D extends Info {
-    nucleus: string;
-    spectralWidth: number;
-    originFrequency: number;
-    baseFrequency?: number;
-    digitalFilter?: number;
-    frequencyOffset?: number;
-    owner?: string;
-    reverse?: boolean;
-    decim?: number;
-    dspfvs?: number;
-    lpNumberOfCoefficients?: number;
-    tdOff?: number;
-    spectrumSize?: number;
-    numberOfPoints?: number;
-    linearPredictionBin?: number;
-}
-
-export declare interface Info2D extends Info {
-    nucleus: string[];
-    isFtDimensionOne: boolean;
-    digitalFilter?: number;
-    originFrequency: number[];
-    baseFrequency: number[];
-    frequencyOffset: number[];
-    spectralWidth: number[];
-    reverse?: boolean[];
-    lpNumberOfCoefficients?: number[];
-    tdOff?: number[];
-    spectrumSize: number[];
-    numberOfPoints: number[];
-    linearPredictionBin?: number[];
-}
-
-export declare interface Integral {
-    id: string;
-    originalFrom: number;
-    originalTo: number;
-    from: number;
-    to: number;
-    absolute: number;
-    integral: number;
-    kind: string;
-}
-
-export declare interface Integrals {
-    values: Integral[];
-    options: SumOptions;
-}
-
 export declare function isEmptyMolecule(molecule: Molecule): boolean;
 
 export declare function isMolfileNotEmpty(molFile?: string): molFile is string;
@@ -1081,20 +1004,15 @@ declare interface JAxisKeys {
     intensity: string;
 }
 
-export declare interface Jcoupling {
-    coupling: number;
-    atoms?: number[];
-    assignment?: string | string[];
-    diaIDs?: string[];
-    multiplicity?: string;
-    pathLength?: number;
-}
-
 declare type JcouplingFromPrediction = MakeMandatory<Jcoupling, 'multiplicity' | 'diaIDs' | 'pathLength'>;
 
-declare interface LabelField extends BaseField {
-    type: 'label';
-}
+declare type LevenbergMarquardtOptimizationOptionsDefaultsKeys = Extract<'minValues' | 'maxValues' | 'initialValues' | 'gradientDifference' | keyof typeof defaultLMOptimizationOptions, keyof LevenbergMarquardtOptions>;
+
+declare type LevenbergMarquardtOptionsDefault = Pick<LevenbergMarquardtOptions, LevenbergMarquardtOptionsWithDefaultKeys>;
+
+declare type LevenbergMarquardtOptionsOverride = Omit<LevenbergMarquardtOptions, LevenbergMarquardtOptionsWithDefaultKeys>;
+
+declare type LevenbergMarquardtOptionsWithDefaultKeys = 'initialValues' | 'minValues' | 'maxValues' | keyof typeof defaultLMOptimizationOptions_2;
 
 declare interface LineShapeData {
     id: string;
@@ -1114,9 +1032,22 @@ declare interface LineShapeData {
     };
 }
 
-declare interface ListField extends Field<string[]> {
-    type: 'list';
-    properties: Record<string, CommonField>;
+declare interface LineShapeResult {
+    id: string;
+    parentID: string;
+    name: string;
+    remarks: string;
+    spinSystemFlags: number[];
+    lineWidth: {
+        value: number;
+        low: number;
+        high: number;
+    };
+    gaussian: {
+        value: number;
+        low: number;
+        high: number;
+    };
 }
 
 declare type MakeMandatory<T, K extends keyof T> = T & {
@@ -1213,40 +1144,6 @@ export declare type MatchingMultiplicity = MultipletDefinition & {
     isBroad: boolean;
 };
 
-declare interface MatrixFilter {
-    name: FilterXYType['name'];
-    properties: MatrixProperties;
-    options: any;
-}
-
-export declare interface MatrixOptions {
-    /**
-     * Matrix generation filters
-     * @default []
-     */
-    filters: Array<MatrixFilter & {
-        options: object;
-    }>;
-    /**
-     * Exclusion zones
-     * @default []
-     */
-    exclusionsZones: ExclusionZone[];
-    /**
-     * range
-     */
-    range: {
-        from: number;
-        to: number;
-    };
-    /**
-     * number of points
-     */
-    numberOfPoints: number;
-}
-
-declare type MatrixProperties = Record<string, Properties>;
-
 export declare function matrixToBoxPlot(input: NumberArray[], options?: {
     colors?: string[];
 }): {
@@ -1292,13 +1189,6 @@ export declare interface MultipletDefinition {
 
 export declare const MultiplicityPatterns: MultipletDefinition[];
 
-export declare interface NMRPeak1D extends PeakXYWidth {
-    id?: string;
-    kind?: string;
-    shape?: Shape1D;
-    originalX?: number;
-}
-
 export declare interface NMRPeak1DFull extends NMRPeak1D {
     id: string;
     shape: Shape1DWithFWHM;
@@ -1307,19 +1197,6 @@ export declare interface NMRPeak1DFull extends NMRPeak1D {
 
 export declare type NMRPeak1DWithShapeID = MakeMandatory<NMRPeak1D, 'id' | 'shape'>;
 
-export declare interface NMRRange {
-    from: number;
-    to: number;
-    id?: string;
-    assignment?: string;
-    diaIDs?: string[];
-    kind?: string;
-    pubIntegral?: number;
-    integration?: number;
-    multiplicity?: string;
-    signals?: NMRSignal1D[];
-}
-
 declare interface NMRRangeWithIds extends Omit<NMRRange, 'id' | 'signals'> {
     id: string;
     signals: NMRSignal1DWithId[];
@@ -1327,20 +1204,6 @@ declare interface NMRRangeWithIds extends Omit<NMRRange, 'id' | 'signals'> {
 
 export declare type NMRRangeWithIntegration = MakeMandatory<NMRRange, 'integration'>;
 
-export declare interface NMRSignal1D {
-    delta: number;
-    id?: string;
-    js?: Jcoupling[];
-    atoms?: number[];
-    assignment?: string;
-    kind?: string;
-    multiplicity?: string;
-    diaIDs?: string[];
-    nbAtoms?: number;
-    integration?: number;
-    peaks?: NMRPeak1D[];
-}
-
 export declare type NMRSignal1DFromPrediction = MakeMandatory<NMRSignal1D, 'nbAtoms' | 'atoms' | 'diaIDs'> & {
     statistics?: XRobustDistributionStats;
     metadata?: HOSEPrediction;
@@ -1350,7 +1213,7 @@ export declare type NMRSignal1DWithAtomsAndDiaIDs = MakeMandatory<NMRSignal1D, '
 
 export declare type NMRSignal1DWithId = MakeMandatory<NMRSignal1D, 'id'>;
 
-export declare interface NMRSignal2D<T extends Peak2D_2 = Peak2D_2> {
+export declare interface NMRSignal2D<T extends Peak2D = Peak2D> {
     x: Signal2DProjection;
     y: Signal2DProjection;
     j?: {
@@ -1361,7 +1224,7 @@ export declare interface NMRSignal2D<T extends Peak2D_2 = Peak2D_2> {
     kind?: string;
 }
 
-export declare type NMRSignal2DWithID<T extends Peak2D_2 = Peak2D_2> = MakeMandatory<NMRSignal2D<T>, 'id'>;
+export declare type NMRSignal2DWithID<T extends Peak2D = Peak2D> = MakeMandatory<NMRSignal2D<T>, 'id'>;
 
 export declare type NMRSignal2DWithId = MakeMandatory<NMRSignal2D, 'id'>;
 
@@ -1385,21 +1248,15 @@ declare interface NMRZoneWithIds extends Omit<NMRZone, 'signals' | 'id'> {
  */
 export declare function normalizeNucleus(nucleus: string): string;
 
-declare interface NumberField extends Field<number> {
-    type: 'number';
+declare interface NucleusType {
+    atomicNumber: number;
+    isotope: number;
 }
 
 declare type NumToNumFn = (x: number) => number;
 
 declare type NUSDimension2 = FilterFactory<Entry2D, IndirectDimensionOptions> & Pick<NUSDimension2Options, 'name'>;
 
-declare interface NUSDimension2Options extends BaseFilter {
-    name: 'nusDimension2';
-    value: IndirectDimensionOptions;
-}
-
-declare type ObjectKeys = 'id' | 'multiplicity' | 'js';
-
 export declare interface ObservedNucleusData {
     /**
      * nucleus to use as reference in the calculation of frequency
@@ -1411,6 +1268,11 @@ export declare interface ObservedNucleusData {
     frequency: number;
 }
 
+export declare interface OneDimensionalAssignment {
+    score: number;
+    assignment: NMRRangeWithIntegration[];
+}
+
 declare interface OneDOptions {
     proton: FromTo;
     carbon: FromTo;
@@ -1422,7 +1284,7 @@ export declare type OneLetterMultiplet = 's' | 'd' | 't' | 'q' | 'i' | 'h' | 'p'
 
 export declare function optimizeSignals(data: DataXY, signals: Signal[], options: OptimizeSignalsOptions): {
     delta: number;
-    js: Jcoupling_2[];
+    js: Jcoupling[];
     shape: {
         kind: "gaussian" | "lorentzian" | "pseudoVoigt" | "generalizedLorentzian";
         fwhm: number;
@@ -1443,10 +1305,22 @@ export declare interface OptimizeSignalsOptions {
     baseline?: number;
     shape?: Shape1D;
     parameters?: ParametersFromOptions;
-    optimization?: any;
+    optimization?: OptimizeSignalsOptionsOptimization;
     simulation: SignalsToPointXYOptions;
 }
 
+declare interface OptimizeSignalsOptionsDirectOptimization {
+    kind: 'direct';
+    options: Partial<Pick<DirectOptimizationOptions, DirectOptimizationOptionsDefaultsKeys>> & Omit<DirectOptimizationOptions, DirectOptimizationOptionsDefaultsKeys>;
+}
+
+declare interface OptimizeSignalsOptionsLevenbergMarquardtOptimization {
+    kind: 'lm';
+    options: Partial<Pick<LevenbergMarquardtOptions, LevenbergMarquardtOptimizationOptionsDefaultsKeys>> & Omit<LevenbergMarquardtOptions, LevenbergMarquardtOptimizationOptionsDefaultsKeys>;
+}
+
+export declare type OptimizeSignalsOptionsOptimization = OptimizeSignalsOptionsDirectOptimization | OptimizeSignalsOptionsLevenbergMarquardtOptimization;
+
 export declare interface OptionsPeaksFilterImpurities {
     /**
      * Solvent name.
@@ -1605,31 +1479,27 @@ declare type ParametersFromSignal = Record<string, Record<string, number>>;
 export declare function parseCT(json: CTJSONInput, molfile: string, options: {
     logger?: LightLogger;
     atomicNumber?: number;
-}): {
+}): ParseCTOutput;
+
+export declare interface ParseCTOutput extends CTParserResult {
     signals: CTSignal[];
-    atomsMapping: Array<AtomMapping>;
-    atomsMappingLookup: Record<string, number>;
-    molfile: string;
-    id: string;
-    shifts: ParsedShift[];
-    couplings: ParsedCoupling[];
-};
+}
 
-export declare interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
-    originalX?: number;
+/**
+ * Interface for coupling data between atoms
+ */
+declare interface ParsedCoupling {
+    from: Atom[];
+    to: Atom[];
+    value: number;
 }
 
-export declare interface Peak2D extends BasePeak {
-    x: number;
-    y: number;
-    z: number;
-    originalX?: number;
-    originalY?: number;
-    originalZ?: number;
-    width?: number | {
-        x: number;
-        y: number;
-    };
+/**
+ * Interface for chemical shift data
+ */
+declare interface ParsedShift {
+    atoms: Atom[];
+    value: number;
 }
 
 export declare interface Peak2DSeries {
@@ -1638,11 +1508,6 @@ export declare interface Peak2DSeries {
     z: number[];
 }
 
-export declare interface Peaks {
-    values: Peak1D[];
-    options: any;
-}
-
 /**
  * Filters impurities from a list of NMR peaks based on the specified options.
  * @template T - The type of NMR peaks.
@@ -1702,62 +1567,10 @@ export declare interface PeaksToXYOptions extends OptionsSG1D {
 
 export declare function peakToXY(peak: NMRPeak1D, options: PeaksToXYOptions): DataXY<Float64Array<ArrayBufferLike>>;
 
-declare interface PhaseCorrection {
-    mode?: string;
-    ph0?: number;
-    ph1?: number;
-}
-
 declare type PhaseCorrection1D = FilterFactory<Entry1D, PhaseCorrection1DOptions> & Pick<PhaseCorrection1DFilterOptions, 'name'>;
 
-declare interface PhaseCorrection1DFilterOptions extends BaseFilter {
-    name: 'phaseCorrection';
-    value: PhaseCorrection1DOptions;
-}
-
-export declare interface PhaseCorrection1DOptions {
-    absolute?: boolean;
-    ph0?: number;
-    ph1?: number;
-}
-
 declare type PhaseCorrection2D = FilterFactory<Entry2D, PhaseCorrectionTwoDFilter> & Pick<PhaseCorrection2DOptions, 'name'>;
 
-declare interface PhaseCorrection2DOptions extends BaseFilter {
-    name: 'phaseCorrectionTwoDimensions';
-    value: PhaseCorrectionTwoDFilter;
-}
-
-declare interface PhaseCorrection_2 {
-    mode?: string;
-    ph0?: number;
-    ph1?: number;
-}
-
-declare interface PhaseCorrectionHorizontalOptions {
-    ph0: number;
-    ph1: number;
-}
-
-declare interface PhaseCorrectionTwoDFilter extends PhaseCorrectionTwoDOptions {
-    automatic?: AutoPhaseCorrection2D;
-}
-
-export declare interface PhaseCorrectionTwoDOptions {
-    horizontal?: PhaseCorrectionHorizontalOptions;
-    vertical?: PhaseCorrectionVerticalOptions;
-}
-
-declare type PhaseCorrectionVerticalOptions = PhaseCorrectionHorizontalOptions & {
-    quad?: 'imag' | 'real';
-};
-
-export declare interface PolynomialOptions {
-    zones: BaselineCorrectionZone[];
-    algorithm: 'polynomial';
-    degree: number;
-}
-
 declare interface PopulationInput {
     id: ID;
     pid: ID;
@@ -1769,6 +1582,19 @@ declare interface PopulationInput {
     sf: number[];
 }
 
+declare interface PopulationOutput {
+    id: ID;
+    parentID: ID;
+    name: string;
+    remarks: string;
+    population: {
+        value: number;
+        low: number;
+        high: number;
+    };
+    spinSystemFlags: number[];
+}
+
 /**
  * Generate the 2D correlation nmr peaks based on the number of bonds between a pair of atoms
  * @param molecule
@@ -2052,21 +1878,8 @@ declare interface PredictSpectraResult {
     }>;
 }
 
-declare type Properties = ListField | SelectField | StringField | NumberField | BooleanField | LabelField;
-
 export declare const protonImpurities: DatabaseNMREntry[];
 
-declare interface Range_2 extends Omit<NMRRange, 'signals' | 'id'> {
-    id: string;
-    originalFrom?: number;
-    originalTo?: number;
-    absolute: number;
-    signals: Signal1D[];
-    integration: number;
-    nbAtoms?: number;
-}
-export { Range_2 as Range }
-
 export declare function rangeFromSignal(signal: NMRSignal1D, options?: RangeFromSignalOptions): {
     from: number;
     to: number;
@@ -2091,11 +1904,6 @@ export declare interface RangeFromSignalOptions {
 
 declare type RangeFullfiled = MakeMandatory<NMRRange, 'integration' | 'signals' | 'id'>;
 
-export declare interface Ranges {
-    values: Range_2[];
-    options: SumOptions;
-}
-
 export declare function rangesToACS(ranges: NMRRange[], options?: RangesToACSOptions): string;
 
 export declare interface RangesToACSOptions {
@@ -2232,51 +2040,19 @@ export declare interface ResurrectOptions {
     logger?: Logger;
 }
 
-declare interface SelectField extends Field<any> {
-    type: 'select';
-    choices: any[];
-}
-
 declare function setNbAtoms(range: Range_2, signalIndex?: number): void;
 
 declare type Shape1DWithFWHM = Omit<Shape1D, 'fwhm'> & {
     fwhm: number;
 };
 
-export declare interface Shapes {
-    exponential?: ShapesFactory<ExponentialOptions>;
-    sineBell?: ShapesFactory<SineBellOptions>;
-    sineSquare?: ShapesFactory<SineSquareOptions>;
-    traf?: ShapesFactory<TrafOptions>;
-    gaussian?: ShapesFactory<GaussianOptions>;
-}
-
-declare interface ShapesFactory<Options> {
-    apply: boolean;
-    options: Options;
-}
-
 declare type Shift2DX = FilterFactory<Entry2D, Shift2DXOptions> & Pick<Shift2DXFilterOptions, 'name'>;
 
-declare interface Shift2DXFilterOptions extends BaseFilter {
-    name: 'shift2DX';
-    value: Shift2DXOptions;
-}
-
-declare interface Shift2DXOptions {
-    shift: number;
-}
+declare type Shift2DXOptions = Shift2DXFilterOptions['value'];
 
 declare type Shift2DY = FilterFactory<Entry2D, Shift2DYOptions> & Pick<Shift2DYFilterOptions, 'name'>;
 
-declare interface Shift2DYFilterOptions extends BaseFilter {
-    name: 'shift2DY';
-    value: Shift2DYOptions;
-}
-
-declare interface Shift2DYOptions {
-    shift: number;
-}
+declare type Shift2DYOptions = Shift2DYFilterOptions['value'];
 
 declare interface ShiftGroupEntry {
     id: string;
@@ -2310,45 +2086,30 @@ declare interface ShiftInput {
     sg: ID;
 }
 
+declare interface ShiftOutput {
+    id: ID;
+    parentID: ID;
+    name: string;
+    remarks: string;
+    shiftGroup: ID;
+}
+
 declare type ShiftTarget = 'origin' | 'current';
 
 declare type ShiftX = FilterFactory<Entry1D, ShiftXOptions> & Pick<ShiftXFilterOptions, 'name'>;
 
-declare interface ShiftXFilterOptions extends BaseFilter {
-    name: 'shiftX';
-    value: ShiftXOptions;
-}
-
-declare interface ShiftXOptions {
-    shift: number;
-}
-
 export declare interface Signal extends NMRSignal1D {
     intensity?: number;
     shape?: Shape1D;
     parameters?: ParametersFromSignal;
 }
 
-export declare interface Signal1D extends Required<Pick<NMRSignal1D, ObjectKeys>>, Omit<NMRSignal1D, ObjectKeys> {
-    originalDelta?: number;
-}
-
 declare type Signal1DWidthDiaID = MakeMandatory<NMRSignal1D, 'diaIDs'>;
 
 declare type Signal1DWidthJsAndDiaID = Omit<Signal1DWidthDiaID, 'js'> & {
     js: JcouplingFromPrediction[];
 };
 
-export declare interface Signal2D extends Signal_2 {
-    sign?: number;
-    x: SignalAxis;
-    y: SignalAxis;
-    peaks?: Peak2D[];
-    j?: {
-        pathLength?: number | FromTo;
-    };
-}
-
 export declare interface Signal2DProjection {
     nucleus?: string;
     delta: number;
@@ -2357,18 +2118,6 @@ export declare interface Signal2DProjection {
     diaIDs?: string[];
 }
 
-declare interface Signal_2 {
-    id: string;
-    kind?: string;
-}
-
-declare interface SignalAxis {
-    delta: number;
-    nbAtoms?: number;
-    diaIDs?: string[];
-    originalDelta: number;
-}
-
 /**
  * Join couplings smaller than a defined tolerance.
  * The resulting coupling should be an average of the existing one.
@@ -2413,12 +2162,7 @@ export declare function signalMultiplicityPattern(signal: NMRSignal1D, options?:
     acsFormat?: boolean;
 }): string;
 
-declare type SignalProcessing = FilterFactory<Entry1D, MatrixOptions> & Pick<SignalProcessingFilter, 'name'>;
-
-declare interface SignalProcessingFilter extends BaseFilter {
-    name: 'signalProcessing';
-    value: MatrixOptions;
-}
+declare type SignalProcessing = FilterFactory<Entry1D, MatrixOptions<FilterOptions>> & Pick<SignalProcessingFilter, 'name'>;
 
 export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): {
     minX: number;
@@ -2616,23 +2360,11 @@ declare interface SineBell<ShapeOption = SineBellOptions> {
     options: ShapeOption;
 }
 
-declare interface SineBellOptions {
-    /**
-     * Specifies the starting point of the sine-bell in units of pi radians.
-     * Common values are 0.0 (for a sine window which starts height at 0.0) and
-     * 0.5 (for a cosine window, which starts at height 1.0).
-     * @default 0
-     */
-    offset: number;
-}
-
 declare interface SineSquare<ShapeOption = SineBellOptions> {
     kind: 'sineSquare';
     options: ShapeOption;
 }
 
-declare type SineSquareOptions = Omit<SineBellOptions, 'exponent'>;
-
 export declare type SolventImpurities = Record<string, Impurity>;
 
 export declare function solventSuppression<T extends NMRPeak1D>(peakList: T[], solvent: NMRSignal1D[], options?: {
@@ -2728,42 +2460,8 @@ export declare interface SplitSpinSystemOptions {
     maxClusterSize?: number;
 }
 
-declare interface StringField extends Field<string> {
-    type: 'string';
-}
-
-export declare interface SumOptions {
-    /**
-     * @default true
-     */
-    isSumConstant: boolean;
-    /**
-     * If you force the "sum" the mf should not be exists any more otherwise if mf is exists the "sum" must be null or undefined
-     * @default undefined
-     */
-    sum: number | undefined;
-    /**
-     * @default true
-     */
-    sumAuto: boolean;
-    /**
-     * mf will be set automatically for the first time based on the first molecules unless the user change it
-     * example 'C10H20O3'
-     */
-    mf?: string;
-    /**
-     * key of the selected molecule
-     */
-    moleculeId?: string;
-}
-
 declare type SymmetrizeCosyLike = FilterFactory<Entry2D, Record<string, never>> & Pick<SymmetrizeCosyLikeOptions, 'name'>;
 
-declare interface SymmetrizeCosyLikeOptions extends BaseFilter {
-    name: 'symmetrizeCosyLike';
-    value: Record<string, never>;
-}
-
 declare class T1Regression extends BaseRegression {
     fullMagnetization: number;
     relaxationT1: number;
@@ -2778,13 +2476,6 @@ declare interface Traf<ShapeOption = TrafOptions> {
     options: ShapeOption;
 }
 
-declare interface TrafOptions {
-    /**
-     * line broadening value in Hz, a negative value will invert the shape
-     */
-    lineBroadening: number;
-}
-
 /**
  * convert from pattern name to only one letter abbreviation or any supported abbreviation to pattern name.
  * @param name - pattern name or abbreviation.
@@ -2876,7 +2567,7 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
   * @param data
   * @param options
   */
- export declare function xyAutoRangesPicking(data: DataXY<Float64Array>, options: OptionsXYAutoRangesPicking): NMRRange_2[];
+ 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.
@@ -2894,11 +2585,13 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
      signalAbsenseDiffussion: number;
  };
 
- export declare function xyCalculateT1(data: DataXY, options?: CalculateT1Options): {
+ 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;
@@ -2937,7 +2630,7 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
   */
  export declare function xyzAutoPhaseCorrection(data: NmrData2DFt, options?: AutoPhaseCorrection2D): Required<PhaseCorrectionTwoDOptions>;
 
- export declare function xyzAutoSignalsPicking(spectraData: NmrData2DContent, options: XYZAutoSignalsPickingOptions): NMRSignal2DWithID<Peak2D_2 & {
+ export declare function xyzAutoSignalsPicking(spectraData: NmrData2DContent, options: XYZAutoSignalsPickingOptions): NMRSignal2DWithID<Peak2D & {
      id: string;
  }>[];
 
@@ -3055,7 +2748,9 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
      kernel?: GetKernelOptions;
  }
 
- export declare function xyzJResAnalyzer(signals: NMRSignal2D[], options?: XYZJResAnalyzerOptions): any[];
+ export declare function xyzJResAnalyzer(signals: NMRSignal2D[], options?: XYZJResAnalyzerOptions): NMRZoneWithID_2[] | (NMRSignal2D<Peak2D> & {
+     id: string;
+ })[];
 
  declare interface XYZJResAnalyzerOptions extends CompilePatternOptions {
      /**
@@ -3081,53 +2776,13 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
 
  declare type ZeroFillingDimension1 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension1Options, 'name'>;
 
- declare interface ZeroFillingDimension1Options extends BaseFilter {
-     name: 'zeroFillingDimension1';
-     value: ZeroFillingOptions;
- }
-
  declare type ZeroFillingDimension2 = FilterFactory<Entry2D, ZeroFillingOptions> & Pick<ZeroFillingDimension2Options, 'name'>;
 
- declare interface ZeroFillingDimension2Options extends BaseFilter {
-     name: 'zeroFillingDimension2';
-     value: ZeroFillingOptions;
- }
-
- declare interface ZeroFillingFilterOptions extends BaseFilter {
-     name: 'zeroFilling';
-     value: ZeroFillingOptions;
- }
-
- export declare interface ZeroFillingOptions {
-     nbPoints: number;
- }
-
- export declare interface Zone {
-     id: string;
-     x: ZoneAxis;
-     y: ZoneAxis;
-     signals: Signal2D[];
-     kind?: string;
-     assignment?: string;
- }
-
  export declare interface Zone2DError {
      x: number;
      y: number;
  }
 
- declare interface ZoneAxis extends FromTo {
-     nbAtoms?: number;
-     diaIDs?: string[];
-     originalFrom?: number;
-     originalTo?: number;
- }
-
- export declare interface Zones {
-     values: Zone[];
-     options?: any;
- }
-
 
  export * from "gyromagnetic-ratio";