nmr-processing 13.0.2 → 13.0.3-pre.1730476792

package/nmr-processing.d.ts

@@ -30,17 +30,11 @@ import { PointXY } from 'cheminfo-types';
 import { Shape1D } from 'ml-peak-shape-generator';
 import { Spectrum2D } from 'spectrum-generator';
 import { TopicMolecule } from 'openchemlib-utils';
+import { XYEquallySpacedOptions } from 'ml-spectra-processing';
 import type { XYNumber } from 'spectrum-generator';
 
 declare function addDefaultSignal(range: Range_2): void;
 
-declare function addFilter(datum: Entry1D | Entry2D, filterOptions: FilterOption, options?: AddFilterOptions): void;
-
-declare interface AddFilterOptions {
-    filterIndex?: number;
-    isDeleteAllow?: boolean;
-}
-
 export declare interface AirplsOptions {
     zones: BaselineCorrectionZone[];
     algorithm: 'airpls';
@@ -48,54 +42,83 @@ export declare interface AirplsOptions {
     tolerance: number;
 }
 
-export declare function apodization(data: DataReIm | DataXReIm, options?: ApodizationFilterOptions): {
-    windowData: Float64Array;
-    x: DoubleArray;
-    re: DoubleArray;
-    im: DoubleArray;
-} | {
-    windowData: Float64Array;
-    /** Array of re values */
-    re: DoubleArray;
-    /** Array of im values */
-    im: DoubleArray;
-};
+declare type Apodization1D = Filter1DInterface<'apodization', 'Apodization', Apodization2DOptions>;
 
-export declare interface Apodization1DOptions {
-    apply?: boolean;
-    shapes?: Apodization2DOptions;
+declare interface Apodization1DFilterOptions extends BaseFilter {
+    name: 'apodization';
+    value: Apodization2DOptions;
 }
 
-export declare type Apodization2DOptions = Shapes<FlexibleWindowFunctions>;
+declare type Apodization2DOptions = Shapes<FlexibleWindowFunctions>;
+export { Apodization2DOptions as Apodization1DOptions }
+export { Apodization2DOptions }
+
+declare type ApodizationDimension1 = Filter2DInterface<'apodizationDimension1', 'Apodization on Dimension 1', Apodization2DOptions>;
 
-export declare function apodizationFilter(datum1D: Entry1DApodizationFilter, options: Apodization1DOptions): {
-    re: DoubleArray;
-    im: DoubleArray;
+declare interface ApodizationDimension1Options extends BaseFilter {
+    name: 'apodizationDimension1';
+    value: Apodization2DOptions;
+}
+
+declare type ApodizationDimension2 = Filter2DInterface<'apodizationDimension2', 'Apodization on Dimension 2', Apodization2DOptions>;
+
+declare interface ApodizationDimension2Options extends BaseFilter {
+    name: 'apodizationDimension2';
+    value: Apodization2DOptions;
+}
+
+export declare function apodizationXReIm(data: Required<NmrData1D>, options: Apodization2DOptions): {
+    x: Float64Array;
+    re: Float64Array;
+    im: Float64Array;
 };
 
-export declare interface ApodizationFilterOptions {
+/**
+ * pure function that applies a window function to the input data.
+ */
+export declare function apodize(data: DoubleArray, options: ApplyWindowOptions): Float64Array;
+
+declare interface ApplyFilterOptions {
     /**
-     * number of points at the end of the shape to apply the window function inverted
-     * @default 0
+     * reapply all the filters using the original data, even if there is a previous filter applied.
      */
-    pointsToShift?: number;
-    compose?: Partial<ShapeOptions<FlexibleWindowFunctions>>;
+    forceReapply?: boolean;
     /**
-     * apply the window data to input data
-     * @default true
+     * filter position at the moment to add a new filter
      */
-    apply?: boolean;
-    windowData?: Float64Array;
+    filterIndex?: number;
+}
+
+declare interface ApplyFilterOptions_2 {
+    /**
+     * reapply all the filters using the original data, even if there is a previous filter applied.
+     */
+    forceReapply?: boolean;
+    /**
+     * filter position at the moment to add a new filter
+     */
+    filterIndex?: number;
 }
 
 /***
  * @param {object} Filters [{name:'',options:{}},{...}]
  */
-declare function applyFilter(datum: Entry1D | Entry2D, filters?: BaseFilter[], options?: ApplyFilterOptions): void;
+declare function applyFilters(datum: Entry1D, filters?: Filter1DOptions[], options?: ApplyFilterOptions): void;
 
-declare interface ApplyFilterOptions {
-    forceReapply?: boolean;
-    filterIndex?: number;
+/***
+ * @param {object} Filters [{name:'',options:{}},{...}]
+ */
+declare function applyFilters_2(datum: Entry2D, filters?: Filter2DOptions[], options?: ApplyFilterOptions_2): void;
+
+export declare interface ApplyWindowOptions {
+    /**
+     * data of a window function it should be scaled to max = 1 to ensure compatibility with new apodizations.
+     */
+    windowData: DoubleArray;
+    /**
+     * output array
+     */
+    output?: DoubleArray;
 }
 
 declare type AtomTypes = 'H' | 'C';
@@ -112,6 +135,27 @@ export declare interface AutoPhaseCorrectionOptions {
     reverse?: boolean;
 }
 
+declare type BackwardLinearPrediction1D = Filter1DInterface<'backwardLinearPrediction', 'Backward Linear Prediction Filter', Partial<BackwardLPOptions>>;
+
+declare interface BackwardLinearPredictionFilterOptions extends BaseFilter {
+    name: 'backwardLinearPrediction';
+    value: Partial<BackwardLPOptions>;
+}
+
+declare type BackwardLPDimension1 = Filter2DInterface<'blpDimension1', 'Backward-LP Dimension 1', Partial<BackwardLPOptions>>;
+
+declare interface BackwardLPDimension1Options extends BaseFilter {
+    name: 'blpDimension1';
+    value: Partial<BackwardLPOptions>;
+}
+
+declare type BackwardLPDimension2 = Filter2DInterface<'blpDimension2', 'Backward-LP Dimension 2', Partial<BackwardLPOptions>>;
+
+declare interface BackwardLPDimension2Options extends BaseFilter {
+    name: 'blpDimension2';
+    value: Partial<BackwardLPOptions>;
+}
+
 export declare interface BackwardLPOptions {
     /**
      * Number of coefficients to be calculated in the SVD.
@@ -138,9 +182,7 @@ declare interface BaseField {
     description: string;
 }
 
-export declare interface BaseFilter {
-    name: string;
-    value: any;
+declare interface BaseFilter {
     isDeleteAllow?: boolean;
     flag?: boolean | null;
     label?: string;
@@ -148,6 +190,20 @@ export declare interface BaseFilter {
 
 export declare type BaselineAlgorithms = 'airpls' | 'polynomial';
 
+declare type BaselineCorrection1D = Filter1DInterface<'baselineCorrection', 'Baseline correction', BaselineCorrectionOptions>;
+
+declare type BaselineCorrection2D = Filter2DInterface<'baselineCorrectionTwoDimensions', 'Baseline correction', Record<string, never>>;
+
+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 {
@@ -247,6 +303,11 @@ export declare const couplingACSPatterns: string[];
 
 export declare const couplingPatterns: string[];
 
+export declare function createApodizationWindowData(options: {
+    shapes?: Shapes;
+    length: number;
+}): Float64Array;
+
 /**
  * This function converts a set of 2D-peaks in 2D-signals. Each signal could be composed
  * of many 2D-peaks, and it has some additional information related to the NMR spectrum.
@@ -297,13 +358,6 @@ export declare interface DatabaseNMREntry {
 
 export declare type DataBaseStructure = DataBaseLevelStructure[];
 
-export declare interface DataReIm {
-    /** Array of re values */
-    re: DoubleArray;
-    /** Array of im values */
-    im: DoubleArray;
-}
-
 export declare interface DataResurrect {
     info: {
         solvent?: string;
@@ -322,7 +376,31 @@ export declare const DatumKind: {
     mixed: string;
 };
 
-declare function deleteFilter(datum: Entry1D | Entry2D, id?: string): void;
+declare function deleteFilter(datum: Entry1D, id?: string): void;
+
+declare function deleteFilter_2(datum: Entry2D, id?: string): void;
+
+declare type DigitalFilter = Filter1DInterface<'digitalFilter', 'Digital Filter', DigitalFilterOptions>;
+
+declare type DigitalFilter2D = Filter2DInterface<'digitalFilter2D', 'Digital filter on Dimension 1', DigitalFilterOptions_2>;
+
+declare interface DigitalFilter2DOptions extends BaseFilter {
+    name: 'digitalFilter2D';
+    value: DigitalFilterOptions_2;
+}
+
+declare interface DigitalFilterOption extends BaseFilter {
+    name: 'digitalFilter';
+    value: DigitalFilterOptions;
+}
+
+declare interface DigitalFilterOptions {
+    digitalFilterValue: number;
+}
+
+declare interface DigitalFilterOptions_2 {
+    digitalFilterValue?: number;
+}
 
 export declare interface DirectDimensionOptions {
     acquisitionScheme?: string;
@@ -333,9 +411,14 @@ export declare interface DirectDimensionOptions {
 
 declare type EmptyValue = void | undefined | null;
 
-declare function enableFilter(datum: Entry1D | Entry2D, id: string | null, checked: boolean | null, filters?: Filter[]): void;
+declare function enableFilter(datum: Entry1D, id: string | null, checked: boolean | null, filters?: Filter1DOptions[]): void;
+
+declare function enableFilter_2(datum: Entry2D, id: string | null, checked: boolean | null, filters?: Filter2DOptions[]): void;
 
-declare type Entry = Entry1D | Entry2D;
+export declare function ensureShapesOptions(data: DataXReIm, shapes?: Partial<Shapes<FlexibleWindowFunctions>>): {
+    shapes: Partial<Record<"exponential" | "gaussian" | "lorentzToGauss" | "modifiedGaussian" | "sineBell" | "sineSquare" | "traf", ShapeToAdd<WindowFunctions>>>;
+    length: number;
+};
 
 declare interface Entry1D {
     id?: string;
@@ -346,14 +429,9 @@ declare interface Entry1D {
     ranges: Ranges;
     info: Info1D;
     originalInfo?: Info1D;
-    filters: Filter[];
+    filters: Filter1D[];
 }
 
-declare type Entry1DApodizationFilter = Partial<Omit<Entry1D, 'info'>> & {
-    info: Partial<Info1D>;
-    data: Required<NmrData1D>;
-};
-
 declare interface Entry2D<T extends NmrData2D = NmrData2D> {
     id?: string;
     zones: Zones;
@@ -362,7 +440,16 @@ declare interface Entry2D<T extends NmrData2D = NmrData2D> {
     originalInfo?: Record<string, any>;
     data: T;
     originalData?: T;
-    filters: Filter[];
+    filters: Filter2D[];
+}
+
+declare type EquallySpaced = Filter1DInterface<'equallySpaced', 'Equally spaced', EquallySpacedFilterOptions>;
+
+declare type EquallySpacedFilterOptions = Pick<XYEquallySpacedOptions, 'from' | 'to' | 'numberOfPoints' | 'exclusions'>;
+
+declare interface EquallySpacedOptions extends BaseFilter {
+    name: 'equallySpaced';
+    value: EquallySpacedFilterOptions;
 }
 
 declare interface ExclusionZone {
@@ -371,6 +458,13 @@ declare interface ExclusionZone {
     to: number;
 }
 
+declare type ExclusionZones = Filter1DInterface<'exclusionZones', 'Exclusion zones', FromTo[]>;
+
+declare interface ExclusionZonesOptions extends BaseFilter {
+    name: 'exclusionZones';
+    value: FromTo[];
+}
+
 declare interface Exponential<ShapeOption = ExponentialOptions> {
     kind: 'exponential';
     options: ShapeOption;
@@ -388,6 +482,27 @@ declare interface ExponentialOptions {
     dw: number;
 }
 
+declare type FFT1D = Filter1DInterface<'fft', 'FFT', Record<string, never>>;
+
+declare interface FFT1DOptions extends BaseFilter {
+    name: 'fft';
+    value: Record<string, never>;
+}
+
+declare type FFTDimension1 = Filter2DInterface<'fftDimension1', 'FFT Dimension 1', DirectDimensionOptions>;
+
+declare interface FFTDimension1Options extends BaseFilter {
+    name: 'fftDimension1';
+    value: DirectDimensionOptions;
+}
+
+declare type FFTDimension2 = Filter2DInterface<'fftDimension2', 'FFT Dimension 2', IndirectDimensionOptions>;
+
+declare interface FFTDimension2Options extends BaseFilter {
+    name: 'fftDimension2';
+    value: IndirectDimensionOptions;
+}
+
 export declare function fftDirectDimension(data: {
     re: DoubleArray[];
     im: DoubleArray[];
@@ -405,50 +520,128 @@ declare interface Field<T> extends BaseField {
     default: T;
 }
 
-export declare interface Filter extends Required<BaseFilter> {
-    id: string;
+declare interface Filter extends Required<BaseFilter> {
+    id?: string;
     error?: string;
 }
 
-declare interface FilterContent {
-    apply: any;
-    reduce: any;
-    isApplicable: any;
-    name: string;
-    id: string;
+export declare type Filter1D = Filter1DOptions & Filter;
+
+declare type Filter1DContent = FFT1D | BaselineCorrection1D | BackwardLinearPrediction1D | Apodization1D | DigitalFilter | EquallySpaced | ExclusionZones | ForwardLP1D | PhaseCorrection1D | ShiftX | SignalProcessing | ZeroFilling;
+
+declare interface Filter1DInterface<ID extends string, Name extends string, Options extends object> {
+    /**
+     * this will help at the moment to identify filters.
+     */
+    id: ID;
+    /**
+     * name of the filter to be presented in the GUI.
+     */
+    name: Name;
+    isApplicable: (datum1D: Entry1D) => boolean;
+    /**
+     * Filter function that process the data in place.
+     */
+    apply: (datum1D: Entry1D, options: Options) => void;
+    /** 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: Options, newValue: Options) => {
+        /**
+         * if it is true and there is only one filter to be applied
+         * FiltersManager will applied the filter on the processed data.
+         */
+        once: boolean;
+        /**
+         * reduced value of the filter to be applied.
+         */
+        reduce: Options;
+    };
     DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
 }
 
+export declare type Filter1DOptions = BaselineCorrectionFilterOptions | FFT1DOptions | ZeroFillingFilterOptions | SignalProcessingFilter | ShiftXFilterOptions | PhaseCorrection1DFilterOptions | ForwardLP1DOptions | ExclusionZonesOptions | EquallySpacedOptions | DigitalFilterOption | Apodization1DFilterOptions | BackwardLinearPredictionFilterOptions;
+
+export declare type Filter2D = Filter2DOptions & Filter;
+
+declare type Filter2DContent = ApodizationDimension1 | ApodizationDimension2 | BaselineCorrection2D | BackwardLPDimension1 | BackwardLPDimension2 | FFTDimension1 | FFTDimension2 | FordwardLPDimension1 | FordwardLPDimension2 | DigitalFilter2D | PhaseCorrection2D | ZeroFillingDimension1 | ZeroFillingDimension2 | SymmetrizeCosyLike | Shift2DX | Shift2DY;
+
+declare interface Filter2DInterface<ID extends string, Name extends string, Options extends object> {
+    /**
+     * this will help at the moment to identify filters.
+     */
+    id: ID;
+    /**
+     * name of the filter to be presented in the GUI.
+     */
+    name: Name;
+    isApplicable: (datum1D: Entry2D) => boolean;
+    /**
+     * Filter function that process the data in place.
+     */
+    apply: (datum1D: Entry2D, options: Options) => void;
+    /** 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: Options, newValue: Options) => {
+        /**
+         * if it is true and there is only one filter to be applied
+         * FiltersManager will applied the filter on the processed data.
+         */
+        once: boolean;
+        /**
+         * reduced value of the filter to be applied.
+         */
+        reduce: Options;
+    };
+    DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules_2>;
+}
+
+export declare type Filter2DOptions = ApodizationDimension1Options | ApodizationDimension2Options | BaselineCorrection2DFilterOptions | BackwardLPDimension1Options | BackwardLPDimension2Options | DigitalFilter2DOptions | FFTDimension1Options | FFTDimension2Options | FordwardLPDimension1Options | FordwardLPDimension2Options | PhaseCorrection2DOptions | Shift2DXFilterOptions | Shift2DYFilterOptions | SymmetrizeCosyLikeOptions | ZeroFillingDimension1Options | ZeroFillingDimension2Options;
+
 declare interface FilterDomainUpdateRules {
     updateYDomain: boolean;
     updateXDomain: boolean;
 }
 
-declare interface FilterOption {
-    name: string;
-    label: string;
-    value: any;
+declare interface FilterDomainUpdateRules_2 {
+    updateYDomain: boolean;
+    updateXDomain: boolean;
 }
 
-export declare const Filters: Record<string, FilterContent>;
-
-export declare const Filters1D: Record<string, FilterContent>;
-
-export declare const Filters2D: Record<string, FilterContent>;
+export declare const Filters1D: {
+    [K in Filter1DContent['id']]: Extract<Filter1DContent, {
+        id: K;
+    }>;
+};
 
-declare namespace FiltersManager {
+declare namespace Filters1DManager {
     export {
-        applyFilter,
-        lookupForFilter,
+        applyFilters,
         reapplyFilters,
         enableFilter,
         deleteFilter,
-        addFilter,
-        FilterDomainUpdateRules,
-        Entry
+        FilterDomainUpdateRules
+    }
+}
+export { Filters1DManager }
+
+export declare const Filters2D: {
+    [K in Filter2DContent['id']]: Extract<Filter2DContent, {
+        id: K;
+    }>;
+};
+
+declare namespace Filters2DManager {
+    export {
+        applyFilters_2 as applyFilters,
+        reapplyFilters_2 as reapplyFilters,
+        enableFilter_2 as enableFilter,
+        deleteFilter_2 as deleteFilter,
+        FilterDomainUpdateRules_2 as FilterDomainUpdateRules
     }
 }
-export { FiltersManager }
+export { Filters2DManager }
 
 /**
  * look for a multiplet based on the pattern name or abbreviation.
@@ -456,7 +649,28 @@ export { FiltersManager }
  */
 export declare function findMultiplet(name: string): MultipletDefinition | undefined;
 
-export declare type FlexibleWindowFunctions = Exponential<Partial<ExponentialOptions>> | LorentToGauss<Partial<LorentzToGaussOptions>> | SineBell<Partial<SineBellOptions>> | SineSquare<Partial<SineSquareOptions>> | Traf<Partial<TrafOptions>> | ModifiedGaussian<Partial<ModifiedGaussianOptions>>;
+export declare type FlexibleWindowFunctions = Exponential<Partial<ExponentialOptions>> | LorentToGauss<Partial<LorentzToGaussOptions>> | SineBell<Partial<SineBellOptions>> | SineSquare<Partial<SineSquareOptions>> | Traf<Partial<TrafOptions>> | ModifiedGaussian<Partial<ModifiedGaussianOptions>> | Gaussian<Partial<GaussianOptions>>;
+
+declare type FordwardLPDimension1 = Filter2DInterface<'flpDimension1', 'Fordward-LP Dimension 1', Partial<BackwardLPOptions>>;
+
+declare interface FordwardLPDimension1Options extends BaseFilter {
+    name: 'flpDimension1';
+    value: Partial<BackwardLPOptions>;
+}
+
+declare type FordwardLPDimension2 = Filter2DInterface<'flpDimension2', 'Fordward-LP Dimension 2', Partial<BackwardLPOptions>>;
+
+declare interface FordwardLPDimension2Options extends BaseFilter {
+    name: 'flpDimension2';
+    value: Partial<BackwardLPOptions>;
+}
+
+declare type ForwardLP1D = Filter1DInterface<'forwardLinearPrediction', 'Forward Linear Prediction Filter', Partial<ForwardLPOptions>>;
+
+declare interface ForwardLP1DOptions extends BaseFilter {
+    name: 'forwardLinearPrediction';
+    value: Partial<ForwardLPOptions>;
+}
 
 export declare interface ForwardLPOptions {
     /**
@@ -477,6 +691,32 @@ export declare interface ForwardLPOptions {
     output?: Float64Array;
 }
 
+declare interface Gaussian<ShapeOption = GaussianOptions> {
+    kind: 'gaussian';
+    options: ShapeOption;
+}
+
+declare interface GaussianOptions {
+    /**
+     * size of the shape function
+     */
+    length: number;
+    /**
+     * increment value in time or the independent value
+     */
+    dw: number;
+    /**
+     * Inverse Exponential Width, Hz
+     * @default 0
+     */
+    lineBroadening?: number;
+    /**
+     * Location of Gauss Maximum, this value should be between 0 to 1
+     * @default 1
+     */
+    lineBroadeningCenter?: number;
+}
+
 export declare function get13CAssignments(ranges: NMRRange[], molecule: Molecule, options?: Get13CAssignmentsOptions): Promise<{
     score: any;
     assignment: unknown[];
@@ -2295,8 +2535,6 @@ declare interface ListField extends Field<string[]> {
     properties: Record<string, CommonField>;
 }
 
-declare function lookupForFilter(datum: Entry1D | Entry2D, filterName: string): Filter | undefined;
-
 declare interface LorentToGauss<ShapeOption = LorentzToGaussOptions> {
     kind: 'lorentzToGauss';
     options: ShapeOption;
@@ -2936,6 +3174,36 @@ declare interface PhaseCorrection {
     ph1?: number;
 }
 
+declare type PhaseCorrection1D = Filter1DInterface<'phaseCorrection', 'Phase correction', PhaseCorrection1DOptions>;
+
+declare interface PhaseCorrection1DFilterOptions extends BaseFilter {
+    name: 'phaseCorrection';
+    value: PhaseCorrection1DOptions;
+}
+
+export declare interface PhaseCorrection1DOptions {
+    absolute?: boolean;
+    ph0?: number;
+    ph1?: number;
+}
+
+declare interface PhaseCorrection2D {
+    id: 'phaseCorrectionTwoDimensions';
+    name: 'Phase correction';
+    isApplicable: (datum2D: Entry2D, options: PhaseCorrectionTwoDFilter) => boolean;
+    apply: (datum2D: Entry2D, options: PhaseCorrectionTwoDFilter) => void;
+    reduce: (previousValue: PhaseCorrectionTwoDFilter, newValue: PhaseCorrectionTwoDFilter) => {
+        once: boolean;
+        reduce: PhaseCorrectionTwoDFilter;
+    };
+    DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules_2>;
+}
+
+declare interface PhaseCorrection2DOptions extends BaseFilter {
+    name: 'phaseCorrectionTwoDimensions';
+    value: PhaseCorrectionTwoDFilter;
+}
+
 declare interface PhaseCorrection_2 {
     mode?: string;
     ph0?: number;
@@ -2947,10 +3215,8 @@ declare interface PhaseCorrectionHorizontalOptions {
     ph1: number;
 }
 
-export declare interface PhaseCorrectionParameters {
-    ph0: number;
-    ph1: number;
-    absolute: boolean;
+declare interface PhaseCorrectionTwoDFilter extends PhaseCorrectionTwoDOptions {
+    automatic?: AutoPhaseCorrection2D;
 }
 
 export declare interface PhaseCorrectionTwoDOptions {
@@ -3357,7 +3623,9 @@ declare namespace RangeUtilities {
 }
 export { RangeUtilities }
 
-declare function reapplyFilters(datum: Entry1D | Entry2D, filters?: Filter[]): void;
+declare function reapplyFilters(datum: Entry1D, filters?: Filter1DOptions[]): void;
+
+declare function reapplyFilters_2(datum: Entry2D, filters?: Filter2DOptions[]): void;
 
 declare function resetDiaIDs(range: Range_2): void;
 
@@ -3390,37 +3658,55 @@ declare type Shape1DWithFWHM = Omit<Shape1D, 'fwhm'> & {
     fwhm: number;
 };
 
-declare interface ShapeOptions<ShapeWindow = WindowFunctions> {
-    /**
-     * length of the window shape
-     */
-    length: number;
-    /**
-     * parameters of the shape plus the kind of shape to identify
-     */
-    shapes?: Shapes<ShapeWindow>;
-}
-
-declare type Shapes<ShapeWindow = WindowFunctions> = Partial<Record<WindowFunctions['kind'], ShapeToAdd<ShapeWindow>>>;
+export declare type Shapes<ShapeWindow = WindowFunctions> = Partial<Record<WindowFunctions['kind'], ShapeToAdd<ShapeWindow>>>;
 
-declare interface ShapeToAdd<ShapeWindows = WindowFunctions> {
+export declare interface ShapeToAdd<ShapeWindows = WindowFunctions> {
     /**
      * if it is false the shape is not included in the apodization
      * @default true
      */
     apply?: boolean;
-    /**
-     * Start Location for Applying Apodize Window
-     */
-    start?: number;
     /**
      * parameters of the shape plus the kind of shape to identify
      */
     shape: ShapeWindows;
 }
 
+declare type Shift2DX = Filter2DInterface<'shift2DX', 'Shift 2D X', Shift2DXOptions>;
+
+declare interface Shift2DXFilterOptions extends BaseFilter {
+    name: 'shift2DX';
+    value: Shift2DXOptions;
+}
+
+declare interface Shift2DXOptions {
+    shift: number;
+}
+
+declare type Shift2DY = Filter2DInterface<'shift2DY', 'Shift 2D Y', Shift2DYOptions>;
+
+declare interface Shift2DYFilterOptions extends BaseFilter {
+    name: 'shift2DY';
+    value: Shift2DYOptions;
+}
+
+declare interface Shift2DYOptions {
+    shift: number;
+}
+
 declare type ShiftTarget = 'origin' | 'current';
 
+declare type ShiftX = Filter1DInterface<'shiftX', 'Shift X', ShiftXOptions>;
+
+declare interface ShiftXFilterOptions extends BaseFilter {
+    name: 'shiftX';
+    value: ShiftXOptions;
+}
+
+declare interface ShiftXOptions {
+    shift: number;
+}
+
 export declare interface Signal extends NMRSignal1D {
     intensity?: number;
     shape?: Shape1D;
@@ -3507,6 +3793,13 @@ export declare function signalMultiplicityPattern(signal: NMRSignal1D, options?:
     acsFormat?: boolean;
 }): string;
 
+declare type SignalProcessing = Filter1DInterface<'signalProcessing', 'Signal processing', MatrixOptions>;
+
+declare interface SignalProcessingFilter extends BaseFilter {
+    name: 'signalProcessing';
+    value: MatrixOptions;
+}
+
 export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): Spectrum2D;
 
 declare interface Signals2DToZOptions {
@@ -3555,12 +3848,8 @@ export declare interface SignalsJoinOptions {
  * imaginary parts, that is why the couplings should be assigned in order to generate the spin system.
  */
 export declare function signalsToFID(signals: NMRSignal1D[], options: SignalsToFIDOptions): {
-    x: DoubleArray;
-    re: DoubleArray;
-    im: DoubleArray;
-} | {
-    re: DoubleArray;
-    im: DoubleArray;
+    re: Float64Array;
+    im: Float64Array;
 };
 
 export declare interface SignalsToFIDOptions {
@@ -3817,6 +4106,13 @@ export declare interface SumOptions {
     moleculeId?: string;
 }
 
+declare type SymmetrizeCosyLike = Filter2DInterface<'symmetrizeCosyLike', 'symmetrize COSY-like', Record<string, never>>;
+
+declare interface SymmetrizeCosyLikeOptions extends BaseFilter {
+    name: 'symmetrizeCosyLike';
+    value: Record<string, never>;
+}
+
 declare class T1Regression extends BaseRegression {
     fullMagnetization: number;
     relaxationT1: number;
@@ -3881,7 +4177,7 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
 
  export declare function updateRangesRelativeValues(spectrum: Entry1D, forceCalculateIntegral?: boolean): void;
 
- export declare type WindowFunctions = Exponential | LorentToGauss | SineBell | SineSquare | Traf | ModifiedGaussian;
+ export declare type WindowFunctions = Exponential | LorentToGauss | SineBell | SineSquare | Traf | ModifiedGaussian | Gaussian;
 
  /**
   * Predict back points by singular value decomposition.
@@ -4087,9 +4383,29 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
 
  export declare function xyzPhaseCorrection(data: NmrData2DFt, options: PhaseCorrectionTwoDOptions): NmrData2DFt;
 
+ declare type ZeroFilling = Filter1DInterface<'zeroFilling', 'Zero Filling', ZeroFillingOptions>;
+
+ declare type ZeroFillingDimension1 = Filter2DInterface<'zeroFillingDimension1', 'Zero filling on Dimension 1', ZeroFillingOptions>;
+
+ declare interface ZeroFillingDimension1Options extends BaseFilter {
+     name: 'zeroFillingDimension1';
+     value: ZeroFillingOptions;
+ }
+
+ declare type ZeroFillingDimension2 = Filter2DInterface<'zeroFillingDimension2', 'Zero filling on Dimension 2', ZeroFillingOptions>;
+
+ declare interface ZeroFillingDimension2Options extends BaseFilter {
+     name: 'zeroFillingDimension2';
+     value: ZeroFillingOptions;
+ }
+
+ declare interface ZeroFillingFilterOptions extends BaseFilter {
+     name: 'zeroFilling';
+     value: ZeroFillingOptions;
+ }
+
  export declare interface ZeroFillingOptions {
-     nbPoints?: number;
-     factor?: number;
+     nbPoints: number;
  }
 
  export declare interface Zone {