react-science 6.0.2 → 8.0.0

package/lib/app-data/state/app_state.d.ts

@@ -0,0 +1,1323 @@
+import { type Dispatch } from 'react';
+import { type AppStateAction } from './app_state.actions.js';
+import { type AppData } from './data/index.js';
+import { type AppSettings } from './settings/index.js';
+import { type AppView } from './view/index.js';
+export interface AppState {
+    load: AppLoad;
+    data: AppData;
+    view: AppView;
+    settings: AppSettings;
+}
+export interface AppLoad {
+    isLoading: boolean;
+}
+export declare function getEmptyAppState(): AppState;
+export declare const appStateContext: import("react").Context<AppState | null>;
+export declare function useAppState(): AppState;
+export type AppDispatch = Dispatch<AppStateAction>;
+export declare const appDispatchContext: import("react").Context<AppDispatch | null>;
+export declare function useAppDispatch(): AppDispatch;
+export declare function useAppData(): AppData;
+export declare function useAppView(): AppView;
+export declare function useAppSettings(): AppSettings;
+export declare const appReducer: (base: {
+    readonly load: {
+        readonly isLoading: boolean;
+    };
+    readonly data: {
+        readonly measurements: {
+            readonly ir: {
+                readonly entries: readonly {
+                    readonly peaks?: readonly {
+                        readonly wavenumber: number;
+                        readonly absorbance: number;
+                        readonly transmittance: number;
+                        readonly kind: import("../index.js").IrPeakKind;
+                    }[] | undefined;
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly iv: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly raman: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly uv: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly uvvis: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly gclc: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly gclcms: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly nmr: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly mass: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+            readonly other: {
+                readonly entries: readonly {
+                    readonly id: string;
+                    readonly info: {
+                        readonly title: string;
+                        readonly file?: {
+                            readonly name: string;
+                            readonly path?: string | undefined;
+                            readonly size?: number | undefined;
+                            readonly lastModified?: number | undefined;
+                        } | undefined;
+                        readonly instrument?: {
+                            readonly model: string;
+                            readonly manufacturer: string;
+                            readonly serialNumber?: string | undefined;
+                            readonly sku?: string | undefined;
+                            readonly software?: {
+                                readonly version?: string | undefined;
+                                readonly name: string;
+                                readonly description?: string | undefined;
+                                readonly url?: string | undefined;
+                            } | undefined;
+                            readonly location?: {
+                                readonly entity: string;
+                                readonly building?: string | undefined;
+                                readonly room?: string | undefined;
+                                readonly code: string;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    readonly meta: {
+                        readonly [x: string]: any;
+                    };
+                    readonly data: readonly {
+                        readonly info?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly meta?: {
+                            readonly [x: string]: any;
+                        } | undefined;
+                        readonly variables: {
+                            readonly [x: string]: {
+                                readonly units?: string | undefined;
+                                readonly label: string;
+                                readonly isDependent?: boolean | undefined;
+                                readonly data: readonly number[] | {
+                                    readonly [x: number]: number;
+                                    readonly BYTES_PER_ELEMENT: number;
+                                    readonly buffer: {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => ArrayBuffer;
+                                        readonly [Symbol.toStringTag]: string;
+                                    } | {
+                                        readonly byteLength: number;
+                                        readonly slice: (begin: number, end?: number) => SharedArrayBuffer;
+                                        readonly [Symbol.species]: any;
+                                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                                    };
+                                    readonly byteLength: number;
+                                    readonly byteOffset: number;
+                                    readonly copyWithin: (target: number, start: number, end?: number) => Float64Array;
+                                    readonly every: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly fill: (value: number, start?: number, end?: number) => Float64Array;
+                                    readonly filter: (predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any) => Float64Array;
+                                    readonly find: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number | undefined;
+                                    readonly findIndex: (predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any) => number;
+                                    readonly forEach: (callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any) => void;
+                                    readonly indexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly join: (separator?: string) => string;
+                                    readonly lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                                    readonly length: number;
+                                    readonly map: (callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any) => Float64Array;
+                                    readonly reduce: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reduceRight: {
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+                                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
+                                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
+                                    };
+                                    readonly reverse: () => Float64Array;
+                                    readonly set: (array: ArrayLike<number>, offset?: number) => void;
+                                    readonly slice: (start?: number, end?: number) => Float64Array;
+                                    readonly some: (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any) => boolean;
+                                    readonly sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Float64Array;
+                                    readonly subarray: (begin?: number, end?: number) => Float64Array;
+                                    readonly toLocaleString: {
+                                        (): string;
+                                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                                    };
+                                    readonly toString: () => string;
+                                    readonly valueOf: () => Float64Array;
+                                    readonly entries: () => ArrayIterator<[number, number]>;
+                                    readonly keys: () => ArrayIterator<number>;
+                                    readonly values: () => ArrayIterator<number>;
+                                    readonly includes: (searchElement: number, fromIndex?: number) => boolean;
+                                    readonly at: (index: number) => number | undefined;
+                                    readonly [Symbol.iterator]: () => ArrayIterator<number>;
+                                    readonly [Symbol.toStringTag]: "Float64Array";
+                                };
+                                readonly symbol?: import("cheminfo-types").OneLetter | undefined;
+                                readonly min?: number | undefined;
+                                readonly max?: number | undefined;
+                                readonly isMonotonic?: (-1 | 0 | 1) | undefined;
+                            };
+                        };
+                    }[];
+                }[];
+            };
+        };
+    };
+    readonly view: {
+        readonly selectedKind?: import("./data/AppData.js").MeasurementKind | undefined;
+        readonly selectedMeasurements: {
+            readonly other?: readonly string[] | undefined;
+            readonly ir?: readonly string[] | undefined;
+            readonly iv?: readonly string[] | undefined;
+            readonly raman?: readonly string[] | undefined;
+            readonly uv?: readonly string[] | undefined;
+            readonly uvvis?: readonly string[] | undefined;
+            readonly gclc?: readonly string[] | undefined;
+            readonly gclcms?: readonly string[] | undefined;
+            readonly nmr?: readonly string[] | undefined;
+            readonly mass?: readonly string[] | undefined;
+        };
+        readonly measurements: {
+            readonly [x: string]: {
+                readonly color: {
+                    readonly kind: "fixed";
+                    readonly color: string;
+                } | {
+                    readonly kind: "fixedGradient";
+                    readonly gradient: import("../../components/index.js").GradientScaleName;
+                };
+                readonly visible: boolean;
+            };
+        };
+        readonly plot: {
+            readonly other?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly ir?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly iv?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly raman?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly uv?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly uvvis?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly gclc?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly gclcms?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly nmr?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+            readonly mass?: {
+                readonly zoom: {
+                    readonly x: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                    readonly y: {
+                        readonly min: number;
+                        readonly max: number;
+                    };
+                };
+                readonly xVariable?: string | undefined;
+                readonly yVariable?: string | undefined;
+            } | undefined;
+        };
+    };
+    readonly settings: {
+        readonly plot: {
+            readonly unselectedOpacity: number;
+        };
+    };
+}, action: AppStateAction) => import("immer").WritableDraft<AppState>;
+//# sourceMappingURL=app_state.d.ts.map