nmr-processing 18.0.1 → 18.1.0

package/{nmr-processing.d.ts → dist/nmr-processing.d.ts}

@@ -1,7 +1,5 @@
 import type { AnalizeMultipletOptions } from 'multiplet-analysis';
-import { AtomMapping } from './ctMolfileParser';
 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';
@@ -14,30 +12,28 @@ 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 { Jcoupling as Jcoupling_2 } from './Jcoupling.js';
 import type { JoinBroadPeaksOptions } from 'ml-gsd';
-import { LightLogger } from 'cheminfo-types';
+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 { 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 { NMRRange as NMRRange_2 } from './NMRRange.js';
 import type { NumberArray } from 'cheminfo-types';
 import type { OCLMolecule } from 'cheminfo-types';
-import { OneLetterMultiplet as OneLetterMultiplet_2 } from './MultiplicityPatterns';
+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 { PeakXYWidth } from 'cheminfo-types';
 import { PointXY } from 'cheminfo-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
-import { SpectraDataWithIds as SpectraDataWithIds_2 } from './nmrAssigment';
+import { SpectraDataWithIds as SpectraDataWithIds_2 } from './nmrAssigment.js';
 import type { TopicMolecule } from 'openchemlib-utils';
 import type { XDistributionStats } from 'ml-spectra-processing';
 import type { XRobustDistributionStats } from 'ml-spectra-processing';
@@ -137,6 +133,8 @@ export declare interface ApplyWindowOptions {
     output?: DoubleArray;
 }
 
+declare type Atom = ReturnType<typeof getAtoms>[0];
+
 declare interface AtomInput {
     id: ID;
     pid: ID;
@@ -157,6 +155,28 @@ declare interface AtomInput {
     s: ID | null;
 }
 
+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 AutoPhaseCorrection2D {
@@ -298,6 +318,14 @@ declare interface BondInput {
     a: [ID, ID];
 }
 
+declare interface BondOutput {
+    id: ID;
+    bondType: string;
+    stereochemistryFlags: number[];
+    spinSystemFlags: number[];
+    atoms: [ID, ID];
+}
+
 declare interface BooleanField extends Field<boolean> {
     type: 'boolean';
 }
@@ -402,6 +430,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 +474,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>;
@@ -889,6 +953,8 @@ export declare interface GetAssignmentsOptions {
     };
 }
 
+declare function getAtoms(a: AtomInput[]): AtomOutput[];
+
 export declare interface GetAutoAssignmentInput {
     spectra: SpectraData[];
     /**
@@ -914,6 +980,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 +1034,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 +1060,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 {
@@ -1114,6 +1240,24 @@ declare interface LineShapeData {
     };
 }
 
+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 interface ListField extends Field<string[]> {
     type: 'list';
     properties: Record<string, CommonField>;
@@ -1385,6 +1529,11 @@ declare interface NMRZoneWithIds extends Omit<NMRZone, 'signals' | 'id'> {
  */
 export declare function normalizeNucleus(nucleus: string): string;
 
+declare interface NucleusType {
+    atomicNumber: number;
+    isotope: number;
+}
+
 declare interface NumberField extends Field<number> {
     type: 'number';
 }
@@ -1605,15 +1754,28 @@ 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[];
-};
+}
+
+/**
+ * Interface for coupling data between atoms
+ */
+declare interface ParsedCoupling {
+    from: Atom[];
+    to: Atom[];
+    value: number;
+}
+
+/**
+ * Interface for chemical shift data
+ */
+declare interface ParsedShift {
+    atoms: Atom[];
+    value: number;
+}
 
 export declare interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
     originalX?: number;
@@ -1769,6 +1931,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
@@ -2310,6 +2485,14 @@ 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'>;