@cosmol-studio/cosmolkit-core 0.5.0 → 0.5.1-rc.2

package/wasm_wasm.d.ts

@@ -1,20 +1,247 @@
 /* tslint:disable */
 /* eslint-disable */
+export interface AddHsParamsOptions {
+    explicitOnly?: boolean;
+    addCoords?: boolean;
+    addResidueInfo?: boolean;
+    skipQueries?: boolean;
+    onlyOnAtoms?: number[] | Uint32Array | null;
+}
+
+
+export interface AromaticityParamsOptions {
+    model?: AromaticityModel | null;
+}
+
+
+export interface AtomPositionParamsOptions {
+    conformerId?: number | null;
+}
+
+
+export interface BatchExportParamsOptions {
+    format?: SdfFormat;
+    errors?: BatchErrorMode | null;
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+}
+
+
+export interface BatchParamsOptions {
+    errors?: BatchErrorMode | null;
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+}
+
+
+export interface BatchQueryParamsOptions {
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+    progressCallback?: (() => void) | null;
+}
+
+
+export interface CipLabelOptionsOptions {
+    atoms?: number[] | null;
+    bonds?: number[] | null;
+    maxRecursiveIterations?: number;
+}
+
+
+export interface Coordinate2DInputParamsOptions {
+    zPolicy?: CoordinateZPolicy | string;
+}
+
+
+export interface Coordinate3DInputParamsOptions {
+    is3d?: boolean;
+}
+
+
+export interface CxSmilesWriteParamsOptions {
+    smiles?: SmilesWriteParams | SmilesWriteParamsOptions;
+    fields?: CxSmilesFields;
+    coordinateSelection?: CxCoordinateSelection;
+}
+
+
+export interface DistanceMatrix3dParamsOptions {
+    conformerId?: number | null;
+    useAtomWeights?: boolean;
+}
+
+
+export interface DistanceMatrixParamsOptions {
+    useBondOrder?: boolean;
+    useAtomWeights?: boolean;
+}
+
+
+export interface FragmentCxSmilesWriteParamsOptions {
+    atoms?: number[];
+    cx?: CxSmilesWriteParams | CxSmilesWriteParamsOptions;
+    bonds?: number[] | null;
+    atomSymbols?: string[] | null;
+    bondSymbols?: string[] | null;
+}
+
+
+export interface FragmentSmilesWriteParamsOptions {
+    atoms?: number[];
+    smiles?: SmilesWriteParams | SmilesWriteParamsOptions;
+    bonds?: number[] | null;
+    atomSymbols?: string[] | null;
+    bondSymbols?: string[] | null;
+}
+
+
+export interface KekulizeParamsOptions {
+    markAtomsBonds?: boolean;
+    canonical?: boolean;
+    maxBacktracks?: number;
+}
+
+
+export interface Mol2ReadParamsOptions {
+    sanitize?: boolean;
+    removeHs?: boolean;
+    variant?: Mol2Type;
+    cleanupSubstructures?: boolean;
+}
+
+
+export interface MolBlockWriteParamsOptions {
+    format?: SdfFormat;
+    force2d?: boolean;
+    includeStereo?: boolean;
+    kekulize?: boolean;
+    precision?: number;
+    coordinateSelection?: MolCoordinateSelection;
+    includeCoordinates?: boolean;
+}
+
+
+export interface PotentialStereoParamsOptions {
+    clean?: boolean;
+    flagPossible?: boolean;
+    allowNontetrahedral?: boolean;
+}
+
+
+export interface RandomSmilesWriteParamsOptions {
+    isomericSmiles?: boolean;
+    kekule?: boolean;
+    allBondsExplicit?: boolean;
+    allHydrogensExplicit?: boolean;
+}
+
+
+export interface RemoveHsParamsOptions {
+    removeDegreeZero?: boolean;
+    removeHigherDegrees?: boolean;
+    removeOnlyHNeighbors?: boolean;
+    removeIsotopes?: boolean;
+    removeAndTrackIsotopes?: boolean;
+    removeDummyNeighbors?: boolean;
+    removeDefiningBondStereo?: boolean;
+    removeWithWedgedBond?: boolean;
+    removeWithQuery?: boolean;
+    removeMapped?: boolean;
+    removeInSgroups?: boolean;
+    showWarnings?: boolean;
+    removeNonimplicit?: boolean;
+    updateExplicitCount?: boolean;
+    removeHydrides?: boolean;
+    removeNontetrahedralNeighbors?: boolean;
+    sanitize?: boolean;
+}
+
+
+export interface Replace3DCoordinatesParamsOptions {
+    conformerId?: number;
+}
+
+
+export interface RingSearchParamsOptions {
+    includeDativeBonds?: boolean;
+    includeHydrogenBonds?: boolean;
+}
+
+
+export interface SanitizeParamsOptions {
+    operations?: SanitizeOperations | null;
+}
+
+
 export interface SdfBatchIterator extends IterableIterator<MoleculeBatch> {}
 export interface SdfReaderBatchIterator extends IterableIterator<MoleculeBatch> {}
 
 export interface SdfDatasetIterator extends IterableIterator<SdfRecord> {}
 
+export interface SdfReadParamsOptions {
+    sanitize?: boolean;
+    removeHs?: boolean;
+    strictParsing?: boolean;
+    expandAttachmentPoints?: boolean;
+    processPropertyLists?: boolean;
+    coordinateMode?: SdfCoordinateMode;
+}
+
+
+export interface SmilesParseParamsOptions {
+    sanitize?: boolean;
+    allowCxsmiles?: boolean;
+    strictCxsmiles?: boolean;
+    parseName?: boolean;
+    removeHs?: boolean;
+    skipCleanup?: boolean;
+    debugParse?: boolean;
+    replacements?: Map<string, string> | Record<string, string> | null;
+}
+
+
+export interface SmilesWriteParamsOptions {
+    isomericSmiles?: boolean;
+    kekule?: boolean;
+    canonical?: boolean;
+    cleanStereo?: boolean;
+    rootedAtAtom?: number | null;
+    allBondsExplicit?: boolean;
+    allHydrogensExplicit?: boolean;
+    includeDativeBonds?: boolean;
+    ignoreAtomMapNumbers?: boolean;
+}
+
+
+export interface StructureTagParamsOptions {
+    conformerId?: number;
+    replaceExistingTags?: boolean;
+}
+
+
+export interface ValenceParamsOptions {
+    model?: ValenceModel;
+    strict?: boolean;
+}
+
+
+export interface XyzWriteParamsOptions {
+    conformerId?: number | null;
+    precision?: number;
+}
+
+
 
 export class AddHsParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(explicit_only?: boolean, add_coords?: boolean, add_residue_info?: boolean, skip_queries?: boolean, only_on_atoms?: number[] | Uint32Array | null);
-    readonly addCoords: boolean;
-    readonly addResidueInfo: boolean;
-    readonly explicitOnly: boolean;
-    readonly onlyOnAtoms: number[] | null;
-    readonly skipQueries: boolean;
+    addCoords: boolean;
+    addResidueInfo: boolean;
+    explicitOnly: boolean;
+    get onlyOnAtoms(): number[] | null;
+    set onlyOnAtoms(value: number[] | Uint32Array | null);
+    skipQueries: boolean;
 }
 
 export class AromaticityError {
@@ -39,7 +266,61 @@ export class AromaticityParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(model?: AromaticityModel | null);
-    readonly model: AromaticityModel;
+    get model(): AromaticityModel;
+    set model(value: AromaticityModel | null);
+}
+
+export class Atom {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    atomMap(): number | null;
+    atomicNumber(): number;
+    chiralTagCode(): number;
+    chiralTagName(): string;
+    chiralTag(): ChiralTag;
+    cipDescriptor(): CipDescriptor | null;
+    cipNeighborOrder(): number[] | null;
+    cipRank(): number | null;
+    element(): Element;
+    explicitHydrogens(): number;
+    formalCharge(): number;
+    hybridization(): Hybridization;
+    id(): number;
+    isAromatic(): boolean;
+    isotope(): number | null;
+    noImplicit(): boolean;
+    radicalElectrons(): number;
+    templateAttachmentOrder(): TemplateAttachmentOrder | null;
+}
+
+export class AtomMetadata {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    degree(): number;
+    explicitValence(): number;
+    implicitHydrogens(): number;
+    totalHydrogens(): number;
+    totalValence(): number;
+}
+
+export class AtomPositionParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(conformer_id?: number | null);
+    conformerId: number | null;
+}
+
+export class AtomSpec {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(element: Element);
+    withAtomMap(value: number): AtomSpec;
+    withExplicitHydrogens(value: number): AtomSpec;
+    withFormalCharge(value: number): AtomSpec;
+    withIsotope(value: number): AtomSpec;
+    withNoImplicit(value: boolean): AtomSpec;
 }
 
 export class BatchError {
@@ -62,10 +343,10 @@ export class BatchExportParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(format?: SdfFormat, errors?: BatchErrorMode | null, n_jobs?: number | null, progress_bar?: boolean | null);
-    readonly errors: BatchErrorMode | null;
-    readonly format: SdfFormat;
-    readonly nJobs: number | null;
-    readonly progressBar: boolean | null;
+    errors: BatchErrorMode | null;
+    format: SdfFormat;
+    nJobs: number | null;
+    progressBar: boolean | null;
 }
 
 export class BatchExportReport {
@@ -84,18 +365,18 @@ export class BatchParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(errors?: BatchErrorMode | null, n_jobs?: number | null, progress_bar?: boolean | null);
-    readonly errors: BatchErrorMode | null;
-    readonly nJobs: number | null;
-    readonly progressBar: boolean | null;
+    errors: BatchErrorMode | null;
+    nJobs: number | null;
+    progressBar: boolean | null;
 }
 
 export class BatchQueryParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(n_jobs?: number | null, progress_bar?: boolean | null, progress_callback?: (() => void) | null);
-    readonly nJobs: number | null;
-    readonly progressBar: boolean | null;
-    readonly progressCallback: (() => void) | null;
+    nJobs: number | null;
+    progressBar: boolean | null;
+    progressCallback: (() => void) | null;
 }
 
 export class BatchRecord {
@@ -121,6 +402,38 @@ export class BatchValidationError {
     readonly recordErrors: BatchError[];
 }
 
+export class Bond {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    begin(): number;
+    cipDescriptor(): CipDescriptor | null;
+    cipNeighborOrder(): number[] | null;
+    directionCode(): number;
+    directionName(): string;
+    direction(): BondDirection;
+    end(): number;
+    id(): number;
+    isAromatic(): boolean;
+    orderCode(): number;
+    orderName(): string;
+    order(): BondOrder;
+    stereoAtoms(): number[] | null;
+    stereoCode(): number;
+    stereoName(): string;
+    stereo(): BondStereo;
+}
+
+export enum BondDirection {
+    None = 0,
+    BeginWedge = 1,
+    BeginDash = 2,
+    EndDownRight = 3,
+    EndUpRight = 4,
+    EitherDouble = 5,
+    Unknown = 6,
+}
+
 export enum BondOrder {
     Unspecified = 0,
     Single = 1,
@@ -146,6 +459,23 @@ export enum BondOrder {
     Zero = 21,
 }
 
+export class BondSpec {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(begin: number, end: number, order: BondOrder | string);
+}
+
+export enum BondStereo {
+    None = 0,
+    Any = 1,
+    Z = 2,
+    E = 3,
+    Cis = 4,
+    Trans = 5,
+    AtropCw = 6,
+    AtropCcw = 7,
+}
+
 export class ChemistryProblem {
     private constructor();
     free(): void;
@@ -171,11 +501,187 @@ export class ChemistryProblemReport {
     readonly problems: ChemistryProblem[];
 }
 
+export enum ChiralTag {
+    Unspecified = 0,
+    TetrahedralCw = 1,
+    TetrahedralCcw = 2,
+    Other = 3,
+    Tetrahedral = 4,
+    Allene = 5,
+    SquarePlanar = 6,
+    TrigonalBipyramidal = 7,
+    Octahedral = 8,
+}
+
+export enum CipDescriptor {
+    R = 0,
+    S = 1,
+    LowerR = 2,
+    LowerS = 3,
+    E = 4,
+    Z = 5,
+    LowerE = 6,
+    LowerZ = 7,
+    M = 8,
+    P = 9,
+    LowerM = 10,
+    LowerP = 11,
+}
+
+export class CipDescriptorError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly kind: string;
+    readonly message: string;
+    readonly value: string | null;
+}
+
+export class CipLabelOptions {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atoms?: number[] | null, bonds?: number[] | null, max_recursive_iterations?: number);
+    atoms: number[] | null;
+    bonds: number[] | null;
+    maxRecursiveIterations: number;
+}
+
+export class CipLabelerError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class Conformer2D {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coordinates(): [number, number][];
+    id(): number;
+    props(): Map<string, string>;
+}
+
+export class Conformer3D {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coordinates(): [number, number, number][];
+    id(): number;
+    is3d(): boolean;
+    props(): Map<string, string>;
+}
+
+export class Coordinate2DInputParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(z_policy?: CoordinateZPolicy | string);
+    get zPolicy(): CoordinateZPolicy;
+    set zPolicy(value: CoordinateZPolicy | string);
+}
+
+export class Coordinate3DInputParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(is_3d?: boolean);
+    is3d: boolean;
+}
+
+export class Coordinate3DReadError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly conformerId: number;
+    readonly count: number;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class CoordinateBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly conformers2d: Conformer2D[];
+    readonly conformers3d: Conformer3D[];
+    readonly sourceConformerOrder: CoordinateDimension[] | null;
+    readonly sourceCoordinateDim: CoordinateDimension | null;
+}
+
 export enum CoordinateDimension {
     TwoD = 0,
     ThreeD = 1,
 }
 
+export class CoordinateInputError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class CoordinateZPolicy {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static fromName(value: string): CoordinateZPolicy;
+    static readonly Error: CoordinateZPolicy;
+    static readonly Ignore: CoordinateZPolicy;
+    static readonly RequireZero: CoordinateZPolicy;
+}
+
+export class CxCoordinateSelection {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static auto(): CxCoordinateSelection;
+    static threeD(id: number): CxCoordinateSelection;
+    static twoD(id: number): CxCoordinateSelection;
+}
+
+export class CxSmilesFields {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    bits(): number;
+    contains(other: CxSmilesFields): boolean;
+    or(other: CxSmilesFields): CxSmilesFields;
+    static readonly ALL_BUT_COORDS: CxSmilesFields;
+    static readonly ALL: CxSmilesFields;
+    static readonly ATOM_LABELS: CxSmilesFields;
+    static readonly ATOM_PROPS: CxSmilesFields;
+    static readonly BOND_ATROPISOMER: CxSmilesFields;
+    static readonly BOND_CFG: CxSmilesFields;
+    static readonly COORDINATE_BONDS: CxSmilesFields;
+    static readonly COORDS: CxSmilesFields;
+    static readonly ENHANCED_STEREO: CxSmilesFields;
+    static readonly HYDROGEN_BONDS: CxSmilesFields;
+    static readonly LINKNODES: CxSmilesFields;
+    static readonly MOLFILE_VALUES: CxSmilesFields;
+    static readonly NONE: CxSmilesFields;
+    static readonly POLYMER: CxSmilesFields;
+    static readonly RADICALS: CxSmilesFields;
+    static readonly SGROUPS: CxSmilesFields;
+    static readonly ZERO_BONDS: CxSmilesFields;
+}
+
+export class CxSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(smiles?: SmilesWriteParams | SmilesWriteParamsOptions, fields?: CxSmilesFields, coordinate_selection?: CxCoordinateSelection);
+    coordinateSelection: CxCoordinateSelection;
+    fields: CxSmilesFields;
+    get smiles(): SmilesWriteParams;
+    set smiles(value: SmilesWriteParams | SmilesWriteParamsOptions);
+}
+
 export class DenseMatrix {
     private constructor();
     free(): void;
@@ -189,16 +695,16 @@ export class DistanceMatrix3dParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(conformer_id?: number | null, use_atom_weights?: boolean);
-    readonly conformerId: number | null;
-    readonly useAtomWeights: boolean;
+    conformerId: number | null;
+    useAtomWeights: boolean;
 }
 
 export class DistanceMatrixParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(use_bond_order?: boolean, use_atom_weights?: boolean);
-    readonly useAtomWeights: boolean;
-    readonly useBondOrder: boolean;
+    useAtomWeights: boolean;
+    useBondOrder: boolean;
 }
 
 export class Element {
@@ -225,6 +731,67 @@ export class ElementInfo {
     valences(): Int32Array;
 }
 
+export class FeatureSpec {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly category: string;
+    readonly docs: string;
+    readonly name: string;
+}
+
+export class FeatureSpecIter {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    next(): FeatureSpec | null;
+}
+
+export class FragmentCxSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atoms?: number[], cx?: CxSmilesWriteParams | CxSmilesWriteParamsOptions, bonds?: number[] | null, atom_symbols?: string[] | null, bond_symbols?: string[] | null);
+    atomSymbols: string[] | null;
+    atoms: number[];
+    bondSymbols: string[] | null;
+    bonds: number[] | null;
+    get cx(): CxSmilesWriteParams;
+    set cx(value: CxSmilesWriteParams | CxSmilesWriteParamsOptions);
+}
+
+export class FragmentSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atoms?: number[], smiles?: SmilesWriteParams | SmilesWriteParamsOptions, bonds?: number[] | null, atom_symbols?: string[] | null, bond_symbols?: string[] | null);
+    atomSymbols: string[] | null;
+    atoms: number[];
+    bondSymbols: string[] | null;
+    bonds: number[] | null;
+    get smiles(): SmilesWriteParams;
+    set smiles(value: SmilesWriteParams | SmilesWriteParamsOptions);
+}
+
+export class FunctionStatus {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly explanation: string | null;
+    readonly kind: string;
+    readonly reference: string | null;
+}
+
+export enum Hybridization {
+    Unspecified = 0,
+    S = 1,
+    Sp = 2,
+    Sp2 = 3,
+    Sp3 = 4,
+    Sp2d = 5,
+    Sp3d = 6,
+    Sp3d2 = 7,
+    Other = 8,
+}
+
 export class HydrogenError {
     private constructor();
     free(): void;
@@ -263,9 +830,17 @@ export class KekulizeParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(mark_atoms_bonds?: boolean, canonical?: boolean, max_backtracks?: number);
-    readonly canonical: boolean;
-    readonly markAtomsBonds: boolean;
-    readonly maxBacktracks: number;
+    canonical: boolean;
+    markAtomsBonds: boolean;
+    maxBacktracks: number;
+}
+
+export class LigandRef {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atom?: number | null);
+    readonly atom: number | null;
+    readonly isImplicitHydrogen: boolean;
 }
 
 export class MatrixError {
@@ -316,10 +891,10 @@ export class Mol2ReadParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(sanitize?: boolean, remove_hs?: boolean, variant?: Mol2Type, cleanup_substructures?: boolean);
-    readonly cleanupSubstructures: boolean;
-    readonly removeHs: boolean;
-    readonly sanitize: boolean;
-    readonly variant: Mol2Type;
+    cleanupSubstructures: boolean;
+    removeHs: boolean;
+    sanitize: boolean;
+    variant: Mol2Type;
 }
 
 export enum Mol2Type {
@@ -330,13 +905,13 @@ export class MolBlockWriteParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(format?: SdfFormat, force_2d?: boolean, include_stereo?: boolean, kekulize?: boolean, precision?: number, coordinate_selection?: MolCoordinateSelection, include_coordinates?: boolean);
-    readonly coordinateSelection: MolCoordinateSelection;
-    readonly force2d: boolean;
-    readonly format: SdfFormat;
-    readonly includeCoordinates: boolean;
-    readonly includeStereo: boolean;
-    readonly kekulize: boolean;
-    readonly precision: number;
+    coordinateSelection: MolCoordinateSelection;
+    force2d: boolean;
+    format: SdfFormat;
+    includeCoordinates: boolean;
+    includeStereo: boolean;
+    kekulize: boolean;
+    precision: number;
 }
 
 export class MolCoordinateSelection {
@@ -393,57 +968,71 @@ export class Molecule {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    addHydrogensWithParams(params: AddHsParams): void;
-    addHydrogens(): void;
-    assignAromaticityWithParams(params: AromaticityParams): void;
-    assignAromaticity(): void;
-    assignRadicals(): void;
-    assignRingFamiliesWithParams(params: RingSearchParams): void;
-    assignRingFamilies(): void;
-    assignRings(): void;
-    assignValenceWithParams(params: ValenceParams): void;
-    assignValence(): void;
+    add3dConformerWithParams_(coordinates: number[][], params: Coordinate3DInputParams): number;
+    add3dConformer_(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): number;
+    addHydrogensWithParams_(params: AddHsParams): void;
+    addHydrogens_(params?: AddHsParams | AddHsParamsOptions): void;
+    assignAromaticityWithParams_(params: AromaticityParams): void;
+    assignAromaticity_(params?: AromaticityParams | AromaticityParamsOptions): void;
+    assignChiralTagsFromStructureWithParams_(params: StructureTagParams): void;
+    assignChiralTagsFromStructure_(params?: StructureTagParams | StructureTagParamsOptions): void;
+    assignCipLabelsWithOptions_(options: CipLabelOptions): void;
+    assignCipLabels_(options?: CipLabelOptions | CipLabelOptionsOptions): void;
+    assignRadicals_(): void;
+    assignRingFamiliesWithParams_(params: RingSearchParams): void;
+    assignRingFamilies_(params?: RingSearchParams | RingSearchParamsOptions): void;
+    assignRings_(): void;
+    assignValenceWithParams_(params: ValenceParams): void;
+    assignValence_(params?: ValenceParams | ValenceParamsOptions): void;
+    atomMetadata(recalculate?: boolean): AtomMetadata[];
     atomPropertyString(id: number, key: string): string | null;
     /**
      * Read typed user metadata; a missing key returns null.
      */
     atomProperty(atom: number, key: string): boolean | number | string | number[] | string[] | null;
+    atom(index: number): Atom | null;
     /**
      * Returns atomic numbers in molecule atom order.
      */
     atomicNumbers(): Uint8Array;
+    atoms(): Atom[];
     bondPropertyString(id: number, key: string): string | null;
+    bond(index: number): Bond | null;
+    bonds(): Bond[];
+    cipComputed(): boolean;
+    clear3dConformers_(): void;
+    conformers3d(): Conformer3D[];
     /**
      * Returns the first 2D conformer as a flattened `[x0, y0, ...]` array.
      */
     coordinates2d(): Float64Array;
-    /**
-     * Returns a 3D conformer as a flattened `[x0, y0, z0, ...]` array.
-     */
-    coordinates3d(conformer_id: number): Float64Array;
+    coordinates3d(conformer_id?: number): Float64Array;
     detectChemistryProblemsWithParams(params: SanitizeParams): ChemistryProblemReport;
-    detectChemistryProblems(): ChemistryProblemReport;
+    detectChemistryProblems(params?: SanitizeParams | SanitizeParamsOptions): ChemistryProblemReport;
     distanceMatrix3dWithParams(params: DistanceMatrix3dParams): DenseMatrix;
-    distanceMatrix3d(): DenseMatrix;
+    distanceMatrix3d(params?: DistanceMatrix3dParams | DistanceMatrix3dParamsOptions): DenseMatrix;
     distanceMatrixWithParams(params: DistanceMatrixParams): DenseMatrix;
-    distanceMatrix(): DenseMatrix;
+    distanceMatrix(params?: DistanceMatrixParams | DistanceMatrixParamsOptions): DenseMatrix;
     findChiralCenters(include_unassigned?: boolean): Array<[number, string]>;
     /**
      * Sanitized components in source order, including conformers; self is unchanged.
      */
     fragments(): Molecule[];
     static fromMol2WithParams(text: string, params: Mol2ReadParams): Molecule;
-    static fromMol2(text: string): Molecule;
+    static fromMol2(text: string, params?: Mol2ReadParams | Mol2ReadParamsOptions): Molecule;
     static fromMolWithParams(text: string, params: SdfReadParams): Molecule;
-    static fromMol(text: string): Molecule;
+    static fromMol(text: string, params?: SdfReadParams | SdfReadParamsOptions): Molecule;
+    static fromParts(topology: TopologyBlock, coordinates: CoordinateBlock, properties: MoleculeProperties): Molecule;
     static fromSdfWithParams(text: string, params: SdfReadParams): Molecule;
-    static fromSdf(text: string): Molecule;
+    static fromSdf(text: string, params?: SdfReadParams | SdfReadParamsOptions): Molecule;
     static fromSmilesWithParams(smiles: string, params: SmilesParseParams): Molecule;
     static fromSmilesWithSanitize(smiles: string, sanitize: boolean): Molecule;
-    static fromSmiles(smiles: string): Molecule;
+    static fromSmiles(smiles: string, params?: SmilesParseParams | SmilesParseParamsOptions): Molecule;
     static fromXyzBlock(text: string): Molecule;
-    kekulizeBondsWithParams(params: KekulizeParams): void;
-    kekulizeBonds(): void;
+    has2dCoordinates(): boolean;
+    hasValenceViolation(atom_id: number): boolean;
+    kekulizeBondsWithParams_(params: KekulizeParams): void;
+    kekulizeBonds_(params?: KekulizeParams | KekulizeParamsOptions): void;
     /**
      * Most atoms, last on ties. Empty input throws OperationError.
      */
@@ -468,6 +1057,10 @@ export class Molecule {
      * Returns the number of 3D conformers.
      */
     numConformers3d(): number;
+    perceiveStereochemistry(): void;
+    potentialStereoWithParams(params: PotentialStereoParams): PotentialStereoResult;
+    potentialStereo(params?: PotentialStereoParams | PotentialStereoParamsOptions): PotentialStereoResult;
+    properties(): MoleculeProperties;
     /**
      * Returns user/computed property names in stable source insertion order.
      */
@@ -477,19 +1070,20 @@ export class Molecule {
      * Wrong value kinds and invalid UTF-8 propagate as binding errors.
      */
     propertyOrEmpty(key: string): string;
+    property(key: string): PropertyValue | null;
     static readMol2WithParams(text: string, params: Mol2ReadParams): Molecule;
-    static readMol2(text: string): Molecule;
+    static readMol2(text: string, params?: Mol2ReadParams | Mol2ReadParamsOptions): Molecule;
     static readMolWithParams(text: string, params: SdfReadParams): Molecule;
-    static readMol(text: string): Molecule;
+    static readMol(text: string, params?: SdfReadParams | SdfReadParamsOptions): Molecule;
     static readSdfWithParams(text: string, params: SdfReadParams): Molecule;
-    static readSdf(text: string): Molecule;
+    static readSdf(text: string, params?: SdfReadParams | SdfReadParamsOptions): Molecule;
     static readXyz(text: string): Molecule;
-    removeHydrogensWithParams(params: RemoveHsParams): void;
-    removeHydrogens(): void;
-    sanitizeWithParams(params: SanitizeParams): Molecule;
+    removeHydrogensWithParams_(params: RemoveHsParams): void;
+    removeHydrogens_(params?: RemoveHsParams | RemoveHsParamsOptions): void;
     sanitizeWithParams_(params: SanitizeParams): void;
-    sanitize(): Molecule;
-    sanitize_(): void;
+    sanitizeWithParams(params: SanitizeParams): Molecule;
+    sanitize_(params?: SanitizeParams | SanitizeParamsOptions): void;
+    sanitize(params?: SanitizeParams | SanitizeParamsOptions): Molecule;
     /**
      * Returns SDF data-field names in their source order, including duplicates.
      */
@@ -498,41 +1092,76 @@ export class Molecule {
      * Returns the first SDF data-field value with `name`, or an empty string.
      */
     sdfDataFieldOrEmpty(name: string): string;
+    set2dCoordinatesWithParams_(coordinates: number[][], params: Coordinate2DInputParams): void;
+    set2dCoordinates_(coordinates: number[][], params?: Coordinate2DInputParams | Coordinate2DInputParamsOptions): void;
+    set3dCoordinatesWithParams_(coordinates: number[][], params: Replace3DCoordinatesParams): void;
+    set3dCoordinates_(coordinates: number[][], params?: Replace3DCoordinatesParams | Replace3DCoordinatesParamsOptions): void;
+    setAtomPositionWithParams_(atom: number, position: [number, number, number], params: AtomPositionParams): void;
+    setAtomPosition_(atom: number, position: [number, number, number], params?: AtomPositionParams | AtomPositionParamsOptions): void;
     /**
      * Set metadata in place; COW keeps other molecule copies unchanged.
      */
-    setAtomProperty(atom: number, key: string, value: boolean | number | string | number[] | string[]): void;
+    setAtomProperty_(atom: number, key: string, value: boolean | number | string | number[] | string[]): void;
+    setOnly3dConformerWithParams_(coordinates: number[][], params: Coordinate3DInputParams): number;
+    setOnly3dConformer_(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): number;
+    tetrahedralStereo(): TetrahedralStereo[];
+    toBuilder(): MoleculeBuilder;
+    toCxSmilesWithParams(params: CxSmilesWriteParams): string;
+    toCxSmiles(params?: CxSmilesWriteParams | CxSmilesWriteParamsOptions): string;
+    toFragmentCxSmilesWithParams(params: FragmentCxSmilesWriteParams): string;
+    toFragmentCxSmiles(atoms: number[], params?: FragmentCxSmilesWriteParams | FragmentCxSmilesWriteParamsOptions): string;
+    toFragmentSmilesWithParams(params: FragmentSmilesWriteParams): string;
+    toFragmentSmiles(atoms: number[], params?: FragmentSmilesWriteParams | FragmentSmilesWriteParamsOptions): string;
     toMolWithParams(params: MolBlockWriteParams): string;
-    toMol(): string;
+    toMol(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
+    toRandomSmilesWithParams(count: number, seed: number, params: RandomSmilesWriteParams): string[];
+    toRandomSmiles(count: number, seed: number, params?: RandomSmilesWriteParams | RandomSmilesWriteParamsOptions): string[];
     toSdf2dWithParams(params: MolBlockWriteParams): string;
-    toSdf2d(): string;
+    toSdf2d(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
     toSdf3dWithParams(params: MolBlockWriteParams): string;
-    toSdf3d(): string;
+    toSdf3d(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
     toSdfWithParams(params: MolBlockWriteParams): string;
-    toSdf(): string;
-    toSmiles(): string;
+    toSdf(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
+    toSmilesWithParams(params: SmilesWriteParams): string;
+    toSmiles(params?: SmilesWriteParams | SmilesWriteParamsOptions): string;
     toXyzWithParams(params: XyzWriteParams): string;
-    toXyz(): string;
+    toXyz(params?: XyzWriteParams | XyzWriteParamsOptions): string;
+    topology(): TopologyBlock;
+    with2dCoordinateBlockWithParams(coordinates: number[][], params: Coordinate2DInputParams): Molecule;
+    with2dCoordinateBlock(coordinates: number[][], params?: Coordinate2DInputParams | Coordinate2DInputParamsOptions): Molecule;
+    with3dCoordinatesWithParams(coordinates: number[][], params: Replace3DCoordinatesParams): Molecule;
+    with3dCoordinates(coordinates: number[][], params?: Replace3DCoordinatesParams | Replace3DCoordinatesParamsOptions): Molecule;
+    withAdded3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): Molecule;
+    withAdded3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): Molecule;
     withAssignedAromaticityWithParams(params: AromaticityParams): Molecule;
-    withAssignedAromaticity(): Molecule;
+    withAssignedAromaticity(params?: AromaticityParams | AromaticityParamsOptions): Molecule;
     withAssignedRadicals(): Molecule;
     withAssignedRingFamiliesWithParams(params: RingSearchParams): Molecule;
-    withAssignedRingFamilies(): Molecule;
+    withAssignedRingFamilies(params?: RingSearchParams | RingSearchParamsOptions): Molecule;
     withAssignedRings(): Molecule;
     withAssignedValenceWithParams(params: ValenceParams): Molecule;
-    withAssignedValence(): Molecule;
+    withAssignedValence(params?: ValenceParams | ValenceParamsOptions): Molecule;
+    withAtomPositionWithParams(atom: number, position: [number, number, number], params: AtomPositionParams): Molecule;
+    withAtomPosition(atom: number, position: [number, number, number], params?: AtomPositionParams | AtomPositionParamsOptions): Molecule;
     /**
      * Return a new molecule; the receiver and its shared copies are unchanged.
      */
     withAtomProperty(atom: number, key: string, value: boolean | number | string | number[] | string[]): Molecule;
+    withChiralTagsFromStructureWithParams(params: StructureTagParams): Molecule;
+    withChiralTagsFromStructure(params?: StructureTagParams | StructureTagParamsOptions): Molecule;
+    withCipLabelsWithOptions(options: CipLabelOptions): Molecule;
+    withCipLabels(options?: CipLabelOptions | CipLabelOptionsOptions): Molecule;
+    withCleared3dConformers(): Molecule;
     withHydrogensWithParams(params: AddHsParams): Molecule;
-    withHydrogens(): Molecule;
+    withHydrogens(params?: AddHsParams | AddHsParamsOptions): Molecule;
     withKekulizedBondsWithParams(params: KekulizeParams): Molecule;
-    withKekulizedBonds(): Molecule;
+    withKekulizedBonds(params?: KekulizeParams | KekulizeParamsOptions): Molecule;
     /**
      * Returns a molecule with its name replaced.
      */
     withName(name: string): Molecule;
+    withOnly3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): Molecule;
+    withOnly3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): Molecule;
     /**
      * Returns a molecule with a string property replaced or inserted.
      */
@@ -542,15 +1171,15 @@ export class Molecule {
      */
     withSdfDataField(key: string, value: string): Molecule;
     withoutHydrogensWithParams(params: RemoveHsParams): Molecule;
-    withoutHydrogens(): Molecule;
+    withoutHydrogens(params?: RemoveHsParams | RemoveHsParamsOptions): Molecule;
     writeMolWithParams(path: string, params: MolBlockWriteParams): void;
-    writeMol(path: string): void;
+    writeMol(path: string, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): void;
     writeSdfFilesWithParams(directory: string, file_name: string | null, params: MolBlockWriteParams): string;
-    writeSdfFiles(directory: string, file_name: string | null): string;
+    writeSdfFiles(directory: string, file_name: string | null, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
     writeSdfWithParams(path: string, params: MolBlockWriteParams): void;
-    writeSdf(path: string): void;
+    writeSdf(path: string, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): void;
     writeXyzWithParams(path: string, params: XyzWriteParams): void;
-    writeXyz(path: string): void;
+    writeXyz(path: string, params?: XyzWriteParams | XyzWriteParamsOptions): void;
 }
 
 export class MoleculeBatch {
@@ -562,9 +1191,9 @@ export class MoleculeBatch {
     static fromDatasetIndices(dataset: SdfDataset, indices: number[] | Uint32Array, error_mode: BatchErrorMode): MoleculeBatch;
     static fromRecords(records: BatchRecord[], mode: BatchErrorMode): MoleculeBatch;
     static fromSdfRecordsWithParams(text: string, read: SdfReadParams, error_mode: BatchErrorMode, n_jobs: number | null): MoleculeBatch;
-    static fromSdfRecords(text: string): MoleculeBatch;
+    static fromSdfRecords(text: string, read?: SdfReadParams | SdfReadParamsOptions): MoleculeBatch;
     static fromSmilesListWithParams(smiles: string[], parse: SmilesParseParams, params: BatchParams): MoleculeBatch;
-    static fromSmilesList(smiles: string[]): MoleculeBatch;
+    static fromSmilesList(smiles: string[], parse?: SmilesParseParams | SmilesParseParamsOptions, params?: BatchParams | BatchParamsOptions): MoleculeBatch;
     get(index: number): BatchRecord | null;
     invalidCount(): number;
     invalidMask(): boolean[];
@@ -573,28 +1202,81 @@ export class MoleculeBatch {
     parallelJobs(): number | null;
     progressBar(): boolean | null;
     static readSdfWithParams(text: string, read: SdfReadParams, error_mode: BatchErrorMode, n_jobs: number | null, progress_bar: boolean): MoleculeBatch;
-    static readSdf(path: string): MoleculeBatch;
+    static readSdf(path: string, read?: SdfReadParams | SdfReadParamsOptions): MoleculeBatch;
     records(): BatchRecord[];
     sanitizeWithParams(options: SanitizeParams, params: BatchParams): MoleculeBatch;
-    sanitize(): MoleculeBatch;
+    sanitize(options?: SanitizeParams | SanitizeParamsOptions, params?: BatchParams | BatchParamsOptions): MoleculeBatch;
     toList(): (Molecule | null)[];
     toSmilesListWithParams(options: SmilesWriteParams, params: BatchQueryParams): (string | null)[];
-    toSmilesList(): (string | null)[];
+    toSmilesList(options?: SmilesWriteParams | SmilesWriteParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (string | null)[];
     validCount(): number;
     validMask(): boolean[];
     withHydrogensWithParams(options: AddHsParams, params: BatchParams): MoleculeBatch;
-    withHydrogens(): MoleculeBatch;
+    withHydrogens(options?: AddHsParams | AddHsParamsOptions, params?: BatchParams | BatchParamsOptions): MoleculeBatch;
     withKekulizedBondsWithParams(options: KekulizeParams, params: BatchParams): MoleculeBatch;
-    withKekulizedBonds(): MoleculeBatch;
+    withKekulizedBonds(options?: KekulizeParams | KekulizeParamsOptions, params?: BatchParams | BatchParamsOptions): MoleculeBatch;
     withParallelJobs(n_jobs: number | null): MoleculeBatch;
     withProgressBar(progress_bar: boolean | null): MoleculeBatch;
     withValidRecords(): MoleculeBatch;
     withoutHydrogensWithParams(options: RemoveHsParams, params: BatchParams): MoleculeBatch;
-    withoutHydrogens(): MoleculeBatch;
+    withoutHydrogens(options?: RemoveHsParams | RemoveHsParamsOptions, params?: BatchParams | BatchParamsOptions): MoleculeBatch;
     writeSdfFilesWithParams(directory: string, params: BatchExportParams, filenames: (string | null)[] | null, report_path: string | null): BatchExportReport;
-    writeSdfFiles(path: string): BatchExportReport;
+    writeSdfFiles(path: string, params?: BatchExportParams | BatchExportParamsOptions): BatchExportReport;
     writeSdfWithParams(path: string, params: BatchExportParams, report_path: string | null): BatchExportReport;
-    writeSdf(path: string): BatchExportReport;
+    writeSdf(path: string, params?: BatchExportParams | BatchExportParamsOptions): BatchExportReport;
+}
+
+export class MoleculeBuilder {
+    free(): void;
+    [Symbol.dispose](): void;
+    add2dConformer(coordinates: number[][]): number;
+    add3dConformer(coordinates: number[][]): number;
+    addAtom(atom: AtomSpec): number;
+    addBond(bond: BondSpec): number;
+    addStereoGroup(group: StereoGroup): number;
+    addSubstanceGroup(group: SubstanceGroup): number;
+    atoms(): Atom[];
+    bondBetweenAtoms(begin: number, end: number): number | null;
+    bonds(): Bond[];
+    build(): Molecule;
+    coordinates(): CoordinateBlock;
+    degree(atom: number): number;
+    static fromParts(topology: TopologyBlock, coordinates: CoordinateBlock, properties: MoleculeProperties): MoleculeBuilder;
+    neighborBonds(atom: number): number[];
+    constructor();
+    properties(): MoleculeProperties;
+    removeBondBetweenAtoms(begin: number, end: number): boolean;
+    set2dCoordinates(coordinates: number[][]): void;
+    setAtomFormalCharge(atom: number, charge: number): void;
+    setBondOrder(bond: number, order: BondOrder | string): void;
+    stereoGroups(): StereoGroup[];
+    substanceGroups(): SubstanceGroup[];
+    withName(name: string): MoleculeBuilder;
+    withProperties(properties: MoleculeProperties): MoleculeBuilder;
+    withProperty(key: string, value: string): MoleculeBuilder;
+    withSdfDataField(key: string, value: string): MoleculeBuilder;
+}
+
+export class MoleculeOpSpec {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly access: { read: number; write: number };
+    readonly autoRemap: number;
+    readonly cipState: string;
+    readonly derivedEffects: { recompute: number; preserve: number; invalidate: number; operationDefined: number };
+    readonly domain: string;
+    readonly implFn: string;
+    readonly ioRoundtrip: boolean;
+    readonly kind: string;
+    readonly mayMutate: number;
+    readonly method: string;
+    readonly output: string;
+    readonly parity: ParityPolicy;
+    readonly requiresMapping: string;
+    readonly resultType: string;
+    readonly semanticPreconditions: number;
+    readonly status: FunctionStatus;
 }
 
 export class MoleculeProperties {
@@ -610,6 +1292,115 @@ export class MoleculeProperties {
     sdfPropertyLists(): SdfPropertyList[];
 }
 
+export class OperationError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class OperationInvariantEntry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly operation: MoleculeOpSpec;
+    readonly profile: string;
+}
+
+export class ParityMatrixEntry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly feature: FeatureSpec;
+    readonly operation: MoleculeOpSpec;
+    readonly profile: string;
+    readonly rdkitVersion: string | null;
+}
+
+export enum ParityPolicy {
+    NotApplicable = 0,
+    RequiredWhenSupported = 1,
+    RequiredNow = 2,
+}
+
+export class PotentialStereoCenter {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly index: number;
+    readonly kind: string;
+}
+
+export enum PotentialStereoDescriptor {
+    None = 0,
+    TetrahedralClockwise = 1,
+    TetrahedralCounterclockwise = 2,
+    BondCis = 3,
+    BondTrans = 4,
+    BondAtropCw = 5,
+    BondAtropCcw = 6,
+}
+
+export class PotentialStereoError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class PotentialStereoInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly centeredOn: PotentialStereoCenter;
+    readonly controllingAtoms: Array<number | null>;
+    readonly descriptor: PotentialStereoDescriptor;
+    readonly permutation: number;
+    readonly specified: PotentialStereoSpecified;
+    readonly stereoType: PotentialStereoType;
+}
+
+export class PotentialStereoParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(clean?: boolean, flag_possible?: boolean, allow_nontetrahedral?: boolean);
+    allowNontetrahedral: boolean;
+    clean: boolean;
+    flagPossible: boolean;
+}
+
+export class PotentialStereoResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly atomRanks: number[];
+    readonly cleanedMolecule: Molecule | null;
+    readonly ringRelations: RingStereoRelation[];
+    readonly stereo: PotentialStereoInfo[];
+}
+
+export enum PotentialStereoSpecified {
+    Unspecified = 0,
+    Specified = 1,
+    Unknown = 2,
+}
+
+export enum PotentialStereoType {
+    AtomTetrahedral = 0,
+    AtomSquarePlanar = 1,
+    AtomTrigonalBipyramidal = 2,
+    AtomOctahedral = 3,
+    BondDouble = 4,
+    BondCumuleneEven = 5,
+    BondAtropisomer = 6,
+}
+
 export class PropertyStringError {
     private constructor();
     free(): void;
@@ -665,35 +1456,61 @@ export class QueryGraph {
     numBonds(): number;
 }
 
+export class RandomSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(isomeric_smiles?: boolean, kekule?: boolean, all_bonds_explicit?: boolean, all_hydrogens_explicit?: boolean);
+    allBondsExplicit: boolean;
+    allHydrogensExplicit: boolean;
+    isomericSmiles: boolean;
+    kekule: boolean;
+}
+
 export class RemoveHsParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(remove_degree_zero?: boolean, remove_higher_degrees?: boolean, remove_only_h_neighbors?: boolean, remove_isotopes?: boolean, remove_and_track_isotopes?: boolean, remove_dummy_neighbors?: boolean, remove_defining_bond_stereo?: boolean, remove_with_wedged_bond?: boolean, remove_with_query?: boolean, remove_mapped?: boolean, remove_in_sgroups?: boolean, show_warnings?: boolean, remove_nonimplicit?: boolean, update_explicit_count?: boolean, remove_hydrides?: boolean, remove_nontetrahedral_neighbors?: boolean, sanitize?: boolean);
-    readonly removeAndTrackIsotopes: boolean;
-    readonly removeDefiningBondStereo: boolean;
-    readonly removeDegreeZero: boolean;
-    readonly removeDummyNeighbors: boolean;
-    readonly removeHigherDegrees: boolean;
-    readonly removeHydrides: boolean;
-    readonly removeInSgroups: boolean;
-    readonly removeIsotopes: boolean;
-    readonly removeMapped: boolean;
-    readonly removeNonimplicit: boolean;
-    readonly removeNontetrahedralNeighbors: boolean;
-    readonly removeOnlyHNeighbors: boolean;
-    readonly removeWithQuery: boolean;
-    readonly removeWithWedgedBond: boolean;
-    readonly sanitize: boolean;
-    readonly showWarnings: boolean;
-    readonly updateExplicitCount: boolean;
+    removeAndTrackIsotopes: boolean;
+    removeDefiningBondStereo: boolean;
+    removeDegreeZero: boolean;
+    removeDummyNeighbors: boolean;
+    removeHigherDegrees: boolean;
+    removeHydrides: boolean;
+    removeInSgroups: boolean;
+    removeIsotopes: boolean;
+    removeMapped: boolean;
+    removeNonimplicit: boolean;
+    removeNontetrahedralNeighbors: boolean;
+    removeOnlyHNeighbors: boolean;
+    removeWithQuery: boolean;
+    removeWithWedgedBond: boolean;
+    sanitize: boolean;
+    showWarnings: boolean;
+    updateExplicitCount: boolean;
+}
+
+export class Replace3DCoordinatesParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(conformer_id?: number);
+    conformerId: number;
 }
 
 export class RingSearchParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(include_dative_bonds?: boolean, include_hydrogen_bonds?: boolean);
-    readonly includeDativeBonds: boolean;
-    readonly includeHydrogenBonds: boolean;
+    includeDativeBonds: boolean;
+    includeHydrogenBonds: boolean;
+}
+
+export class RingStereoRelation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly atom: number;
+    readonly other: number;
+    readonly sameOrientation: boolean;
 }
 
 export class SGroupBracket {
@@ -745,10 +1562,10 @@ export class SanitizeOperations {
     or(other: SanitizeOperations): SanitizeOperations;
     static readonly ADJUST_HS: SanitizeOperations;
     static readonly ALL: SanitizeOperations;
-    static readonly CLEANUP: SanitizeOperations;
     static readonly CLEANUP_ATROPISOMERS: SanitizeOperations;
     static readonly CLEANUP_CHIRALITY: SanitizeOperations;
     static readonly CLEANUP_ORGANOMETALLICS: SanitizeOperations;
+    static readonly CLEANUP: SanitizeOperations;
     static readonly FIND_RADICALS: SanitizeOperations;
     static readonly KEKULIZE: SanitizeOperations;
     static readonly NONE: SanitizeOperations;
@@ -763,7 +1580,8 @@ export class SanitizeParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(operations?: SanitizeOperations | null);
-    readonly operations: SanitizeOperations;
+    get operations(): SanitizeOperations;
+    set operations(value: SanitizeOperations | null);
 }
 
 export enum SanitizeStage {
@@ -806,11 +1624,11 @@ export class SdfDataset {
     len(): number;
     metadata(index: number): SdfRecordMetadata | null;
     static openWithParams(path: string, params: SdfReadParams): SdfDataset;
-    static open(path: string): SdfDataset;
+    static open(path: string, params?: SdfReadParams | SdfReadParamsOptions): SdfDataset;
     path(): string;
     recordText(index: number): string;
     recordWithParams(index: number, params: SdfReadParams): SdfRecord;
-    record(index: number): SdfRecord;
+    record(index: number, params?: SdfReadParams | SdfReadParamsOptions): SdfRecord;
 }
 
 export class SdfDatasetIterator {
@@ -860,16 +1678,30 @@ export enum SdfPropertyListTarget {
     Bond = 1,
 }
 
+/**
+ * Typed snapshot of the concrete SDF reader failure and its source chain.
+ */
+export class SdfReadError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly context: Readonly<Record<string, string | number | bigint>>;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
 export class SdfReadParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(sanitize?: boolean, remove_hs?: boolean, strict_parsing?: boolean, expand_attachment_points?: boolean, process_property_lists?: boolean, coordinate_mode?: SdfCoordinateMode);
-    readonly coordinateMode: SdfCoordinateMode;
-    readonly expandAttachmentPoints: boolean;
-    readonly processPropertyLists: boolean;
-    readonly removeHs: boolean;
-    readonly sanitize: boolean;
-    readonly strictParsing: boolean;
+    coordinateMode: SdfCoordinateMode;
+    expandAttachmentPoints: boolean;
+    processPropertyLists: boolean;
+    removeHs: boolean;
+    sanitize: boolean;
+    strictParsing: boolean;
 }
 
 export class SdfReader {
@@ -878,7 +1710,7 @@ export class SdfReader {
     [Symbol.dispose](): void;
     batches(size?: number, error_mode?: BatchErrorMode, n_jobs?: number | null): SdfReaderBatchIterator & IterableIterator<MoleculeBatch>;
     static openWithParams(path: string, params: SdfReadParams): SdfReader;
-    static open(path: string): SdfReader;
+    static open(path: string, params?: SdfReadParams | SdfReadParamsOptions): SdfReader;
     params(): SdfReadParams;
     path(): string;
 }
@@ -899,7 +1731,7 @@ export class SdfRecord {
     dataFields(): [string, string][];
     static fromQueryGraph(query: QueryGraph, properties: MoleculeProperties): SdfRecord;
     static fromSdfWithParams(text: string, params: SdfReadParams): SdfRecord;
-    static fromSdf(text: string): SdfRecord;
+    static fromSdf(text: string, params?: SdfReadParams | SdfReadParamsOptions): SdfRecord;
     graph(): SdfGraph;
     index(): number;
     molecule(): Molecule;
@@ -909,9 +1741,9 @@ export class SdfRecord {
     substanceGroups(): SubstanceGroup[];
     title(): string | null;
     toMolWithParams(params: MolBlockWriteParams): string;
-    toMol(): string;
+    toMol(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
     toSdfWithParams(params: MolBlockWriteParams): string;
-    toSdf(): string;
+    toSdf(params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
 }
 
 export class SdfRecordMetadata {
@@ -936,7 +1768,7 @@ export class SdfRecordStream {
     linesConsumed(): number;
     nextRecord(): SdfRecord | null;
     static openWithParams(path: string, params: SdfReadParams): SdfRecordStream;
-    static open(path: string): SdfRecordStream;
+    static open(path: string, params?: SdfReadParams | SdfReadParamsOptions): SdfRecordStream;
     recordsConsumed(): number;
 }
 
@@ -954,14 +1786,30 @@ export class SmilesParseParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(sanitize?: boolean, allow_cxsmiles?: boolean, strict_cxsmiles?: boolean, parse_name?: boolean, remove_hs?: boolean, skip_cleanup?: boolean, debug_parse?: boolean, replacements?: Map<string, string> | Record<string, string> | null);
-    readonly allowCxsmiles: boolean;
-    readonly debugParse: boolean;
-    readonly parseName: boolean;
-    readonly removeHs: boolean;
-    readonly replacements: Map<string, string>;
-    readonly sanitize: boolean;
-    readonly skipCleanup: boolean;
-    readonly strictCxsmiles: boolean;
+    allowCxsmiles: boolean;
+    debugParse: boolean;
+    parseName: boolean;
+    removeHs: boolean;
+    get replacements(): Map<string, string>;
+    set replacements(value: Map<string, string> | Record<string, string> | null);
+    sanitize: boolean;
+    skipCleanup: boolean;
+    strictCxsmiles: boolean;
+}
+
+export class SmilesStereoError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly actual: number | null;
+    readonly cause: Error | null;
+    readonly dimension: string | null;
+    readonly domain: string;
+    readonly expected: number | null;
+    readonly field: string | null;
+    readonly id: number | null;
+    readonly kind: string;
+    readonly message: string;
 }
 
 export class SmilesWriteError {
@@ -978,15 +1826,40 @@ export class SmilesWriteParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(isomeric_smiles?: boolean, kekule?: boolean, canonical?: boolean, clean_stereo?: boolean, rooted_at_atom?: number | null, all_bonds_explicit?: boolean, all_hydrogens_explicit?: boolean, include_dative_bonds?: boolean, ignore_atom_map_numbers?: boolean);
-    readonly allBondsExplicit: boolean;
-    readonly allHydrogensExplicit: boolean;
-    readonly canonical: boolean;
-    readonly cleanStereo: boolean;
-    readonly ignoreAtomMapNumbers: boolean;
-    readonly includeDativeBonds: boolean;
-    readonly isomericSmiles: boolean;
-    readonly kekule: boolean;
-    readonly rootedAtAtom: number | null;
+    allBondsExplicit: boolean;
+    allHydrogensExplicit: boolean;
+    canonical: boolean;
+    cleanStereo: boolean;
+    ignoreAtomMapNumbers: boolean;
+    includeDativeBonds: boolean;
+    isomericSmiles: boolean;
+    kekule: boolean;
+    rootedAtAtom: number | null;
+}
+
+export class StereoError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class StereoGroup {
+    free(): void;
+    [Symbol.dispose](): void;
+    atoms(): number[];
+    bonds(): number[];
+    kind(): StereoGroupKind;
+    constructor(kind: StereoGroupKind | string, atoms: number[], bonds?: number[]);
+}
+
+export enum StereoGroupKind {
+    Absolute = 0,
+    Or = 1,
+    And = 2,
 }
 
 export class StereoReadError {
@@ -999,6 +1872,14 @@ export class StereoReadError {
     readonly message: string;
 }
 
+export class StructureTagParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(conformer_id?: number, replace_existing_tags?: boolean);
+    conformerId: number;
+    replaceExistingTags: boolean;
+}
+
 export class SubstanceGroup {
     private constructor();
     free(): void;
@@ -1043,6 +1924,72 @@ export class SubstanceGroupKind {
     readonly genericValue: string | null;
 }
 
+export class SupportMatrixEntry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly feature: FeatureSpec;
+    readonly operation: MoleculeOpSpec | null;
+}
+
+export class TemplateAttachment {
+    free(): void;
+    [Symbol.dispose](): void;
+    label(): string;
+    constructor(target: number, label: string);
+    target(): number;
+}
+
+export class TemplateAttachmentOrder {
+    free(): void;
+    [Symbol.dispose](): void;
+    entries(): TemplateAttachment[];
+    constructor(entries: TemplateAttachment[]);
+}
+
+export class TemplateAttachmentOrderError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly atomCount: number | null;
+    readonly duplicatePosition: number | null;
+    readonly firstPosition: number | null;
+    readonly kind: string;
+    readonly label: string | null;
+    readonly mappingLen: number | null;
+    readonly message: string;
+    readonly position: number | null;
+    readonly target: number | null;
+}
+
+export class TetrahedralStereo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly center: number;
+    readonly ligands: LigandRef[];
+}
+
+export class TopologyBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly atoms: Atom[];
+    readonly bonds: Bond[];
+    readonly stereoGroups: StereoGroup[];
+    readonly substanceGroups: SubstanceGroup[];
+}
+
+export class TransformError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
 export class ValenceError {
     private constructor();
     free(): void;
@@ -1081,8 +2028,8 @@ export class ValenceParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(model?: ValenceModel, strict?: boolean);
-    readonly model: ValenceModel;
-    readonly strict: boolean;
+    model: ValenceModel;
+    strict: boolean;
 }
 
 export class XyzReadError {
@@ -1112,12 +2059,32 @@ export class XyzWriteParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(conformer_id?: number | null, precision?: number);
-    readonly conformerId: number | null;
-    readonly precision: number;
+    conformerId: number | null;
+    precision: number;
 }
 
 export function elementInfo(element: Element): ElementInfo;
 
+export function featureSpec(name: string): FeatureSpec | null;
+
+export function featureSpecs(): FeatureSpecIter;
+
+export function operationInvariant(method: string): OperationInvariantEntry | null;
+
+export function operationInvariantMatrix(): OperationInvariantEntry[];
+
+export function operationParity(method: string): ParityMatrixEntry | null;
+
+export function operationSpec(method: string): MoleculeOpSpec | null;
+
+export function operationSpecs(): MoleculeOpSpec[];
+
+export function parityMatrix(): ParityMatrixEntry[];
+
+export function propertyValueToText(value: PropertyValue): string;
+
+export function supportMatrix(): SupportMatrixEntry[];
+
 /**
  * Returns the COSMolKit version through the binding-facing crate.
  */
@@ -1130,6 +2097,10 @@ export interface InitOutput {
     readonly __wbg_addhsparams_free: (a: number, b: number) => void;
     readonly __wbg_aromaticityerror_free: (a: number, b: number) => void;
     readonly __wbg_aromaticityparams_free: (a: number, b: number) => void;
+    readonly __wbg_atom_free: (a: number, b: number) => void;
+    readonly __wbg_atommetadata_free: (a: number, b: number) => void;
+    readonly __wbg_atompositionparams_free: (a: number, b: number) => void;
+    readonly __wbg_atomspec_free: (a: number, b: number) => void;
     readonly __wbg_batcherror_free: (a: number, b: number) => void;
     readonly __wbg_batchexportparams_free: (a: number, b: number) => void;
     readonly __wbg_batchexportreport_free: (a: number, b: number) => void;
@@ -1137,17 +2108,39 @@ export interface InitOutput {
     readonly __wbg_batchqueryparams_free: (a: number, b: number) => void;
     readonly __wbg_batchrecord_free: (a: number, b: number) => void;
     readonly __wbg_batchvalidationerror_free: (a: number, b: number) => void;
+    readonly __wbg_bond_free: (a: number, b: number) => void;
+    readonly __wbg_bondspec_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblem_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblemerror_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblemreport_free: (a: number, b: number) => void;
+    readonly __wbg_cipdescriptorerror_free: (a: number, b: number) => void;
+    readonly __wbg_ciplabelererror_free: (a: number, b: number) => void;
+    readonly __wbg_ciplabeloptions_free: (a: number, b: number) => void;
+    readonly __wbg_conformer2d_free: (a: number, b: number) => void;
+    readonly __wbg_conformer3d_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate2dinputparams_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate3dinputparams_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate3dreaderror_free: (a: number, b: number) => void;
+    readonly __wbg_coordinateblock_free: (a: number, b: number) => void;
+    readonly __wbg_coordinateinputerror_free: (a: number, b: number) => void;
+    readonly __wbg_coordinatezpolicy_free: (a: number, b: number) => void;
+    readonly __wbg_cxcoordinateselection_free: (a: number, b: number) => void;
+    readonly __wbg_cxsmilesfields_free: (a: number, b: number) => void;
+    readonly __wbg_cxsmileswriteparams_free: (a: number, b: number) => void;
     readonly __wbg_densematrix_free: (a: number, b: number) => void;
     readonly __wbg_distancematrix3dparams_free: (a: number, b: number) => void;
     readonly __wbg_distancematrixparams_free: (a: number, b: number) => void;
     readonly __wbg_element_free: (a: number, b: number) => void;
     readonly __wbg_elementinfo_free: (a: number, b: number) => void;
+    readonly __wbg_featurespec_free: (a: number, b: number) => void;
+    readonly __wbg_featurespeciter_free: (a: number, b: number) => void;
+    readonly __wbg_fragmentcxsmileswriteparams_free: (a: number, b: number) => void;
+    readonly __wbg_fragmentsmileswriteparams_free: (a: number, b: number) => void;
+    readonly __wbg_functionstatus_free: (a: number, b: number) => void;
     readonly __wbg_hydrogenerror_free: (a: number, b: number) => void;
     readonly __wbg_kekulizeerror_free: (a: number, b: number) => void;
     readonly __wbg_kekulizeparams_free: (a: number, b: number) => void;
+    readonly __wbg_ligandref_free: (a: number, b: number) => void;
     readonly __wbg_matrixerror_free: (a: number, b: number) => void;
     readonly __wbg_mol2posterror_free: (a: number, b: number) => void;
     readonly __wbg_mol2readerror_free: (a: number, b: number) => void;
@@ -1157,14 +2150,27 @@ export interface InitOutput {
     readonly __wbg_molecularioerror_free: (a: number, b: number) => void;
     readonly __wbg_molecule_free: (a: number, b: number) => void;
     readonly __wbg_moleculebatch_free: (a: number, b: number) => void;
+    readonly __wbg_moleculebuilder_free: (a: number, b: number) => void;
+    readonly __wbg_moleculeopspec_free: (a: number, b: number) => void;
     readonly __wbg_moleculeproperties_free: (a: number, b: number) => void;
     readonly __wbg_molwriteerror_free: (a: number, b: number) => void;
+    readonly __wbg_operationerror_free: (a: number, b: number) => void;
+    readonly __wbg_operationinvariantentry_free: (a: number, b: number) => void;
+    readonly __wbg_paritymatrixentry_free: (a: number, b: number) => void;
+    readonly __wbg_potentialstereocenter_free: (a: number, b: number) => void;
+    readonly __wbg_potentialstereoerror_free: (a: number, b: number) => void;
+    readonly __wbg_potentialstereoinfo_free: (a: number, b: number) => void;
+    readonly __wbg_potentialstereoparams_free: (a: number, b: number) => void;
+    readonly __wbg_potentialstereoresult_free: (a: number, b: number) => void;
     readonly __wbg_propertystringerror_free: (a: number, b: number) => void;
     readonly __wbg_propertyvalue_free: (a: number, b: number) => void;
     readonly __wbg_propertyvalueerror_free: (a: number, b: number) => void;
     readonly __wbg_querygraph_free: (a: number, b: number) => void;
+    readonly __wbg_randomsmileswriteparams_free: (a: number, b: number) => void;
     readonly __wbg_removehsparams_free: (a: number, b: number) => void;
+    readonly __wbg_replace3dcoordinatesparams_free: (a: number, b: number) => void;
     readonly __wbg_ringsearchparams_free: (a: number, b: number) => void;
+    readonly __wbg_ringstereorelation_free: (a: number, b: number) => void;
     readonly __wbg_sanitizeerror_free: (a: number, b: number) => void;
     readonly __wbg_sanitizeoperations_free: (a: number, b: number) => void;
     readonly __wbg_sanitizeparams_free: (a: number, b: number) => void;
@@ -1176,6 +2182,7 @@ export interface InitOutput {
     readonly __wbg_sdfpropertylist_free: (a: number, b: number) => void;
     readonly __wbg_sdfreader_free: (a: number, b: number) => void;
     readonly __wbg_sdfreaderbatchiterator_free: (a: number, b: number) => void;
+    readonly __wbg_sdfreaderror_free: (a: number, b: number) => void;
     readonly __wbg_sdfreadparams_free: (a: number, b: number) => void;
     readonly __wbg_sdfrecord_free: (a: number, b: number) => void;
     readonly __wbg_sdfrecordmetadata_free: (a: number, b: number) => void;
@@ -1185,12 +2192,23 @@ export interface InitOutput {
     readonly __wbg_sgroupdisplay_free: (a: number, b: number) => void;
     readonly __wbg_smileserror_free: (a: number, b: number) => void;
     readonly __wbg_smilesparseparams_free: (a: number, b: number) => void;
+    readonly __wbg_smilesstereoerror_free: (a: number, b: number) => void;
     readonly __wbg_smileswriteerror_free: (a: number, b: number) => void;
     readonly __wbg_smileswriteparams_free: (a: number, b: number) => void;
+    readonly __wbg_stereoerror_free: (a: number, b: number) => void;
+    readonly __wbg_stereogroup_free: (a: number, b: number) => void;
     readonly __wbg_stereoreaderror_free: (a: number, b: number) => void;
+    readonly __wbg_structuretagparams_free: (a: number, b: number) => void;
     readonly __wbg_substancegroup_free: (a: number, b: number) => void;
     readonly __wbg_substancegroupid_free: (a: number, b: number) => void;
     readonly __wbg_substancegroupkind_free: (a: number, b: number) => void;
+    readonly __wbg_supportmatrixentry_free: (a: number, b: number) => void;
+    readonly __wbg_templateattachment_free: (a: number, b: number) => void;
+    readonly __wbg_templateattachmentorder_free: (a: number, b: number) => void;
+    readonly __wbg_templateattachmentordererror_free: (a: number, b: number) => void;
+    readonly __wbg_tetrahedralstereo_free: (a: number, b: number) => void;
+    readonly __wbg_topologyblock_free: (a: number, b: number) => void;
+    readonly __wbg_transformerror_free: (a: number, b: number) => void;
     readonly __wbg_valenceerror_free: (a: number, b: number) => void;
     readonly __wbg_valenceparams_free: (a: number, b: number) => void;
     readonly __wbg_xyzreaderror_free: (a: number, b: number) => void;
@@ -1201,13 +2219,51 @@ export interface InitOutput {
     readonly addhsparams_explicitOnly: (a: number) => number;
     readonly addhsparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
     readonly addhsparams_onlyOnAtoms: (a: number) => any;
+    readonly addhsparams_set_addCoords: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_addResidueInfo: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_explicitOnly: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_onlyOnAtoms: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_skipQueries: (a: number, b: any) => [number, number];
     readonly addhsparams_skipQueries: (a: number) => number;
     readonly aromaticityerror_cause: (a: number) => [number, number, number];
     readonly aromaticityerror_domain: (a: number) => [number, number];
     readonly aromaticityerror_kind: (a: number) => [number, number];
     readonly aromaticityerror_message: (a: number) => [number, number];
     readonly aromaticityparams_model: (a: number) => number;
-    readonly aromaticityparams_new: (a: number) => number;
+    readonly aromaticityparams_new: (a: any) => [number, number, number];
+    readonly aromaticityparams_set_model: (a: number, b: any) => [number, number];
+    readonly atom_atomMap: (a: number) => any;
+    readonly atom_atomicNumber: (a: number) => number;
+    readonly atom_chiralTag: (a: number) => number;
+    readonly atom_chiralTagCode: (a: number) => number;
+    readonly atom_chiralTagName: (a: number) => [number, number];
+    readonly atom_cipDescriptor: (a: number) => [number, number, number];
+    readonly atom_cipNeighborOrder: (a: number) => [number, number, number];
+    readonly atom_cipRank: (a: number) => [number, number, number];
+    readonly atom_element: (a: number) => [number, number, number];
+    readonly atom_explicitHydrogens: (a: number) => number;
+    readonly atom_formalCharge: (a: number) => number;
+    readonly atom_hybridization: (a: number) => number;
+    readonly atom_id: (a: number) => number;
+    readonly atom_isAromatic: (a: number) => number;
+    readonly atom_isotope: (a: number) => any;
+    readonly atom_noImplicit: (a: number) => number;
+    readonly atom_radicalElectrons: (a: number) => number;
+    readonly atom_templateAttachmentOrder: (a: number) => any;
+    readonly atommetadata_degree: (a: number) => number;
+    readonly atommetadata_explicitValence: (a: number) => number;
+    readonly atommetadata_implicitHydrogens: (a: number) => number;
+    readonly atommetadata_totalHydrogens: (a: number) => number;
+    readonly atommetadata_totalValence: (a: number) => number;
+    readonly atompositionparams_conformerId: (a: number) => any;
+    readonly atompositionparams_new: (a: any) => [number, number, number];
+    readonly atompositionparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly atomspec_new: (a: number) => number;
+    readonly atomspec_withAtomMap: (a: number, b: any) => [number, number, number];
+    readonly atomspec_withExplicitHydrogens: (a: number, b: any) => [number, number, number];
+    readonly atomspec_withFormalCharge: (a: number, b: any) => [number, number, number];
+    readonly atomspec_withIsotope: (a: number, b: any) => [number, number, number];
+    readonly atomspec_withNoImplicit: (a: number, b: any) => [number, number, number];
     readonly batcherror_asDict: (a: number) => [number, number, number];
     readonly batcherror_cause: (a: number) => [number, number, number];
     readonly batcherror_index: (a: number) => number;
@@ -1218,6 +2274,10 @@ export interface InitOutput {
     readonly batchexportparams_nJobs: (a: number) => any;
     readonly batchexportparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
     readonly batchexportparams_progressBar: (a: number) => any;
+    readonly batchexportparams_set_errors: (a: number, b: any) => [number, number];
+    readonly batchexportparams_set_format: (a: number, b: any) => [number, number];
+    readonly batchexportparams_set_nJobs: (a: number, b: any) => [number, number];
+    readonly batchexportparams_set_progressBar: (a: number, b: any) => [number, number];
     readonly batchexportreport_errors: (a: number) => [number, number];
     readonly batchexportreport_failed: (a: number) => number;
     readonly batchexportreport_success: (a: number) => number;
@@ -1226,12 +2286,18 @@ export interface InitOutput {
     readonly batchexportreport_written: (a: number) => number;
     readonly batchparams_errors: (a: number) => any;
     readonly batchparams_nJobs: (a: number) => any;
-    readonly batchparams_new: (a: number, b: any, c: any) => [number, number, number];
+    readonly batchparams_new: (a: any, b: any, c: any) => [number, number, number];
     readonly batchparams_progressBar: (a: number) => any;
+    readonly batchparams_set_errors: (a: number, b: any) => [number, number];
+    readonly batchparams_set_nJobs: (a: number, b: any) => [number, number];
+    readonly batchparams_set_progressBar: (a: number, b: any) => [number, number];
     readonly batchqueryparams_nJobs: (a: number) => any;
     readonly batchqueryparams_new: (a: any, b: any, c: any) => [number, number, number];
     readonly batchqueryparams_progressBar: (a: number) => any;
     readonly batchqueryparams_progressCallback: (a: number) => any;
+    readonly batchqueryparams_set_nJobs: (a: number, b: any) => [number, number];
+    readonly batchqueryparams_set_progressBar: (a: number, b: any) => [number, number];
+    readonly batchqueryparams_set_progressCallback: (a: number, b: any) => [number, number];
     readonly batchrecord_error: (a: number) => number;
     readonly batchrecord_errorValue: (a: number) => any;
     readonly batchrecord_molecule: (a: number) => number;
@@ -1243,6 +2309,23 @@ export interface InitOutput {
     readonly batchvalidationerror_message: (a: number) => [number, number];
     readonly batchvalidationerror_reason: (a: number) => any;
     readonly batchvalidationerror_recordErrors: (a: number) => [number, number];
+    readonly bond_begin: (a: number) => number;
+    readonly bond_cipDescriptor: (a: number) => [number, number, number];
+    readonly bond_cipNeighborOrder: (a: number) => [number, number, number];
+    readonly bond_direction: (a: number) => number;
+    readonly bond_directionCode: (a: number) => number;
+    readonly bond_directionName: (a: number) => [number, number];
+    readonly bond_end: (a: number) => number;
+    readonly bond_id: (a: number) => number;
+    readonly bond_isAromatic: (a: number) => number;
+    readonly bond_order: (a: number) => number;
+    readonly bond_orderCode: (a: number) => number;
+    readonly bond_orderName: (a: number) => [number, number];
+    readonly bond_stereo: (a: number) => number;
+    readonly bond_stereoAtoms: (a: number) => any;
+    readonly bond_stereoCode: (a: number) => number;
+    readonly bond_stereoName: (a: number) => [number, number];
+    readonly bondspec_new: (a: any, b: any, c: any) => [number, number, number];
     readonly chemistryproblem_error: (a: number) => [number, number, number];
     readonly chemistryproblem_operation: (a: number) => number;
     readonly chemistryproblemerror_cause: (a: number) => any;
@@ -1250,13 +2333,92 @@ export interface InitOutput {
     readonly chemistryproblemerror_kind: (a: number) => [number, number];
     readonly chemistryproblemerror_message: (a: number) => [number, number];
     readonly chemistryproblemreport_problems: (a: number) => [number, number];
+    readonly cipdescriptorerror_cause: (a: number) => [number, number, number];
+    readonly cipdescriptorerror_kind: (a: number) => [number, number];
+    readonly cipdescriptorerror_message: (a: number) => [number, number];
+    readonly cipdescriptorerror_value: (a: number) => [number, number, number];
+    readonly ciplabelererror_cause: (a: number) => [number, number, number];
+    readonly ciplabelererror_domain: (a: number) => [number, number];
+    readonly ciplabelererror_kind: (a: number) => [number, number];
+    readonly ciplabelererror_message: (a: number) => [number, number];
+    readonly ciplabeloptions_atoms: (a: number) => any;
+    readonly ciplabeloptions_bonds: (a: number) => any;
+    readonly ciplabeloptions_maxRecursiveIterations: (a: number) => number;
+    readonly ciplabeloptions_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly ciplabeloptions_set_atoms: (a: number, b: any) => [number, number];
+    readonly ciplabeloptions_set_bonds: (a: number, b: any) => [number, number];
+    readonly ciplabeloptions_set_maxRecursiveIterations: (a: number, b: any) => [number, number];
+    readonly conformer2d_coordinates: (a: number) => any;
+    readonly conformer2d_id: (a: number) => number;
+    readonly conformer2d_props: (a: number) => [number, number, number];
+    readonly conformer3d_coordinates: (a: number) => any;
+    readonly conformer3d_id: (a: number) => number;
+    readonly conformer3d_is3d: (a: number) => number;
+    readonly conformer3d_props: (a: number) => [number, number, number];
+    readonly coordinate2dinputparams_new: (a: any) => [number, number, number];
+    readonly coordinate2dinputparams_set_zPolicy: (a: number, b: any) => [number, number];
+    readonly coordinate2dinputparams_zPolicy: (a: number) => number;
+    readonly coordinate3dinputparams_is3d: (a: number) => number;
+    readonly coordinate3dinputparams_new: (a: any) => [number, number, number];
+    readonly coordinate3dinputparams_set_is3d: (a: number, b: any) => [number, number];
+    readonly coordinate3dreaderror_conformerId: (a: number) => number;
+    readonly coordinate3dreaderror_count: (a: number) => number;
+    readonly coordinate3dreaderror_domain: (a: number) => [number, number];
+    readonly coordinate3dreaderror_kind: (a: number) => [number, number];
+    readonly coordinate3dreaderror_message: (a: number) => [number, number];
+    readonly coordinateblock_conformers2d: (a: number) => any;
+    readonly coordinateblock_conformers3d: (a: number) => any;
+    readonly coordinateblock_sourceConformerOrder: (a: number) => any;
+    readonly coordinateblock_sourceCoordinateDim: (a: number) => any;
+    readonly coordinateinputerror_cause: (a: number) => [number, number, number];
+    readonly coordinateinputerror_domain: (a: number) => [number, number];
+    readonly coordinateinputerror_kind: (a: number) => [number, number];
+    readonly coordinateinputerror_message: (a: number) => [number, number];
+    readonly coordinatezpolicy_Error: () => number;
+    readonly coordinatezpolicy_Ignore: () => number;
+    readonly coordinatezpolicy_RequireZero: () => number;
+    readonly coordinatezpolicy_fromName: (a: number, b: number) => [number, number, number];
+    readonly cxcoordinateselection_auto: () => number;
+    readonly cxcoordinateselection_threeD: (a: any) => [number, number, number];
+    readonly cxcoordinateselection_twoD: (a: any) => [number, number, number];
+    readonly cxsmilesfields_ALL: () => number;
+    readonly cxsmilesfields_ALL_BUT_COORDS: () => number;
+    readonly cxsmilesfields_ATOM_LABELS: () => number;
+    readonly cxsmilesfields_ATOM_PROPS: () => number;
+    readonly cxsmilesfields_BOND_ATROPISOMER: () => number;
+    readonly cxsmilesfields_BOND_CFG: () => number;
+    readonly cxsmilesfields_COORDINATE_BONDS: () => number;
+    readonly cxsmilesfields_COORDS: () => number;
+    readonly cxsmilesfields_ENHANCED_STEREO: () => number;
+    readonly cxsmilesfields_HYDROGEN_BONDS: () => number;
+    readonly cxsmilesfields_LINKNODES: () => number;
+    readonly cxsmilesfields_MOLFILE_VALUES: () => number;
+    readonly cxsmilesfields_NONE: () => number;
+    readonly cxsmilesfields_POLYMER: () => number;
+    readonly cxsmilesfields_RADICALS: () => number;
+    readonly cxsmilesfields_SGROUPS: () => number;
+    readonly cxsmilesfields_ZERO_BONDS: () => number;
+    readonly cxsmilesfields_bits: (a: number) => number;
+    readonly cxsmilesfields_contains: (a: number, b: number) => number;
+    readonly cxsmilesfields_or: (a: number, b: number) => number;
+    readonly cxsmileswriteparams_coordinateSelection: (a: number) => number;
+    readonly cxsmileswriteparams_fields: (a: number) => number;
+    readonly cxsmileswriteparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly cxsmileswriteparams_set_coordinateSelection: (a: number, b: any) => [number, number];
+    readonly cxsmileswriteparams_set_fields: (a: number, b: any) => [number, number];
+    readonly cxsmileswriteparams_set_smiles: (a: number, b: any) => [number, number];
+    readonly cxsmileswriteparams_smiles: (a: number) => number;
     readonly densematrix_dimension: (a: number) => number;
     readonly densematrix_get: (a: number, b: any, c: any) => [number, number, number];
     readonly densematrix_values: (a: number) => [number, number];
     readonly distancematrix3dparams_conformerId: (a: number) => any;
     readonly distancematrix3dparams_new: (a: any, b: any) => [number, number, number];
+    readonly distancematrix3dparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly distancematrix3dparams_set_useAtomWeights: (a: number, b: any) => [number, number];
     readonly distancematrix3dparams_useAtomWeights: (a: number) => number;
     readonly distancematrixparams_new: (a: any, b: any) => [number, number, number];
+    readonly distancematrixparams_set_useAtomWeights: (a: number, b: any) => [number, number];
+    readonly distancematrixparams_set_useBondOrder: (a: number, b: any) => [number, number];
     readonly distancematrixparams_useAtomWeights: (a: number) => number;
     readonly distancematrixparams_useBondOrder: (a: number) => number;
     readonly elementInfo: (a: number) => number;
@@ -1272,6 +2434,37 @@ export interface InitOutput {
     readonly elementinfo_rb0: (a: number) => number;
     readonly elementinfo_symbol: (a: number) => [number, number];
     readonly elementinfo_valences: (a: number) => [number, number];
+    readonly featureSpec: (a: number, b: number) => any;
+    readonly featureSpecs: () => number;
+    readonly featurespec_category: (a: number) => [number, number];
+    readonly featurespec_docs: (a: number) => [number, number];
+    readonly featurespec_name: (a: number) => [number, number];
+    readonly featurespeciter_next: (a: number) => any;
+    readonly fragmentcxsmileswriteparams_atomSymbols: (a: number) => any;
+    readonly fragmentcxsmileswriteparams_atoms: (a: number) => any;
+    readonly fragmentcxsmileswriteparams_bondSymbols: (a: number) => any;
+    readonly fragmentcxsmileswriteparams_bonds: (a: number) => any;
+    readonly fragmentcxsmileswriteparams_cx: (a: number) => number;
+    readonly fragmentcxsmileswriteparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
+    readonly fragmentcxsmileswriteparams_set_atomSymbols: (a: number, b: any) => [number, number];
+    readonly fragmentcxsmileswriteparams_set_atoms: (a: number, b: any) => [number, number];
+    readonly fragmentcxsmileswriteparams_set_bondSymbols: (a: number, b: any) => [number, number];
+    readonly fragmentcxsmileswriteparams_set_bonds: (a: number, b: any) => [number, number];
+    readonly fragmentcxsmileswriteparams_set_cx: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_atomSymbols: (a: number) => any;
+    readonly fragmentsmileswriteparams_atoms: (a: number) => any;
+    readonly fragmentsmileswriteparams_bondSymbols: (a: number) => any;
+    readonly fragmentsmileswriteparams_bonds: (a: number) => any;
+    readonly fragmentsmileswriteparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
+    readonly fragmentsmileswriteparams_set_atomSymbols: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_set_atoms: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_set_bondSymbols: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_set_bonds: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_set_smiles: (a: number, b: any) => [number, number];
+    readonly fragmentsmileswriteparams_smiles: (a: number) => number;
+    readonly functionstatus_explanation: (a: number) => any;
+    readonly functionstatus_kind: (a: number) => [number, number];
+    readonly functionstatus_reference: (a: number) => any;
     readonly hydrogenerror_cause: (a: number) => [number, number, number];
     readonly hydrogenerror_domain: (a: number) => [number, number];
     readonly hydrogenerror_kind: (a: number) => [number, number];
@@ -1298,6 +2491,12 @@ export interface InitOutput {
     readonly kekulizeparams_markAtomsBonds: (a: number) => number;
     readonly kekulizeparams_maxBacktracks: (a: number) => number;
     readonly kekulizeparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly kekulizeparams_set_canonical: (a: number, b: any) => [number, number];
+    readonly kekulizeparams_set_markAtomsBonds: (a: number, b: any) => [number, number];
+    readonly kekulizeparams_set_maxBacktracks: (a: number, b: any) => [number, number];
+    readonly ligandref_atom: (a: number) => any;
+    readonly ligandref_isImplicitHydrogen: (a: number) => number;
+    readonly ligandref_new: (a: any) => [number, number, number];
     readonly matrixerror_atom: (a: number) => [number, number, number];
     readonly matrixerror_atomCount: (a: number) => [number, number, number];
     readonly matrixerror_bond: (a: number) => [number, number, number];
@@ -1328,6 +2527,10 @@ export interface InitOutput {
     readonly mol2readparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
     readonly mol2readparams_removeHs: (a: number) => number;
     readonly mol2readparams_sanitize: (a: number) => number;
+    readonly mol2readparams_set_cleanupSubstructures: (a: number, b: any) => [number, number];
+    readonly mol2readparams_set_removeHs: (a: number, b: any) => [number, number];
+    readonly mol2readparams_set_sanitize: (a: number, b: any) => [number, number];
+    readonly mol2readparams_set_variant: (a: number, b: any) => [number, number];
     readonly mol2readparams_variant: (a: number) => number;
     readonly molblockwriteparams_coordinateSelection: (a: number) => number;
     readonly molblockwriteparams_force2d: (a: number) => number;
@@ -1337,6 +2540,13 @@ export interface InitOutput {
     readonly molblockwriteparams_kekulize: (a: number) => number;
     readonly molblockwriteparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
     readonly molblockwriteparams_precision: (a: number) => number;
+    readonly molblockwriteparams_set_coordinateSelection: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_force2d: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_format: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_includeCoordinates: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_includeStereo: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_kekulize: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_precision: (a: number, b: any) => [number, number];
     readonly molcoordinateselection_Auto: () => number;
     readonly molcoordinateselection_ThreeD: (a: any) => [number, number, number];
     readonly molcoordinateselection_TwoD: (a: any) => [number, number, number];
@@ -1358,110 +2568,167 @@ export interface InitOutput {
     readonly molecularioerror_stage: (a: number) => any;
     readonly molecularioerror_threeD: (a: number) => any;
     readonly molecularioerror_twoD: (a: number) => any;
-    readonly molecule_addHydrogens: (a: number) => [number, number];
-    readonly molecule_addHydrogensWithParams: (a: number, b: any) => [number, number];
-    readonly molecule_assignAromaticity: (a: number) => [number, number];
-    readonly molecule_assignAromaticityWithParams: (a: number, b: number) => [number, number];
-    readonly molecule_assignRadicals: (a: number) => [number, number];
-    readonly molecule_assignRingFamilies: (a: number) => [number, number];
-    readonly molecule_assignRingFamiliesWithParams: (a: number, b: any) => [number, number];
-    readonly molecule_assignRings: (a: number) => [number, number];
-    readonly molecule_assignValence: (a: number) => [number, number];
-    readonly molecule_assignValenceWithParams: (a: number, b: number) => [number, number];
+    readonly molecule_add3dConformerWithParams_: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_add3dConformer_: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_addHydrogensWithParams_: (a: number, b: any) => [number, number];
+    readonly molecule_addHydrogens_: (a: number, b: any) => [number, number];
+    readonly molecule_assignAromaticityWithParams_: (a: number, b: number) => [number, number];
+    readonly molecule_assignAromaticity_: (a: number, b: any) => [number, number];
+    readonly molecule_assignChiralTagsFromStructureWithParams_: (a: number, b: number) => [number, number];
+    readonly molecule_assignChiralTagsFromStructure_: (a: number, b: any) => [number, number];
+    readonly molecule_assignCipLabelsWithOptions_: (a: number, b: number) => [number, number];
+    readonly molecule_assignCipLabels_: (a: number, b: any) => [number, number];
+    readonly molecule_assignRadicals_: (a: number) => [number, number];
+    readonly molecule_assignRingFamiliesWithParams_: (a: number, b: any) => [number, number];
+    readonly molecule_assignRingFamilies_: (a: number, b: any) => [number, number];
+    readonly molecule_assignRings_: (a: number) => [number, number];
+    readonly molecule_assignValenceWithParams_: (a: number, b: number) => [number, number];
+    readonly molecule_assignValence_: (a: number, b: any) => [number, number];
+    readonly molecule_atom: (a: number, b: any) => [number, number, number];
+    readonly molecule_atomMetadata: (a: number, b: any) => [number, number, number, number];
     readonly molecule_atomProperty: (a: number, b: any, c: number, d: number) => [number, number, number];
     readonly molecule_atomPropertyString: (a: number, b: any, c: number, d: number) => [number, number, number];
     readonly molecule_atomicNumbers: (a: number) => [number, number];
+    readonly molecule_atoms: (a: number) => [number, number];
+    readonly molecule_bond: (a: number, b: any) => [number, number, number];
     readonly molecule_bondPropertyString: (a: number, b: any, c: number, d: number) => [number, number, number];
+    readonly molecule_bonds: (a: number) => [number, number];
+    readonly molecule_cipComputed: (a: number) => [number, number, number];
+    readonly molecule_clear3dConformers_: (a: number) => [number, number];
+    readonly molecule_conformers3d: (a: number) => any;
     readonly molecule_coordinates2d: (a: number) => [number, number];
-    readonly molecule_coordinates3d: (a: number, b: number) => [number, number];
-    readonly molecule_detectChemistryProblems: (a: number) => [number, number, number];
+    readonly molecule_coordinates3d: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_detectChemistryProblems: (a: number, b: any) => [number, number, number];
     readonly molecule_detectChemistryProblemsWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_distanceMatrix: (a: number) => [number, number, number];
-    readonly molecule_distanceMatrix3d: (a: number) => [number, number, number];
+    readonly molecule_distanceMatrix: (a: number, b: any) => [number, number, number];
+    readonly molecule_distanceMatrix3d: (a: number, b: any) => [number, number, number];
     readonly molecule_distanceMatrix3dWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_distanceMatrixWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_findChiralCenters: (a: number, b: any) => [number, number, number];
     readonly molecule_fragments: (a: number) => [number, number, number, number];
-    readonly molecule_fromMol: (a: number, b: number) => [number, number, number];
-    readonly molecule_fromMol2: (a: number, b: number) => [number, number, number];
+    readonly molecule_fromMol: (a: number, b: number, c: any) => [number, number, number];
+    readonly molecule_fromMol2: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fromMol2WithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fromMolWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fromSdf: (a: number, b: number) => [number, number, number];
+    readonly molecule_fromParts: (a: number, b: number, c: number) => [number, number, number];
+    readonly molecule_fromSdf: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fromSdfWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fromSmiles: (a: number, b: number) => [number, number, number];
+    readonly molecule_fromSmiles: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fromSmilesWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly molecule_fromSmilesWithSanitize: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fromXyzBlock: (a: number, b: number) => [number, number, number];
-    readonly molecule_kekulizeBonds: (a: number) => [number, number];
-    readonly molecule_kekulizeBondsWithParams: (a: number, b: any) => [number, number];
+    readonly molecule_has2dCoordinates: (a: number) => number;
+    readonly molecule_hasValenceViolation: (a: number, b: any) => [number, number, number];
+    readonly molecule_kekulizeBondsWithParams_: (a: number, b: any) => [number, number];
+    readonly molecule_kekulizeBonds_: (a: number, b: any) => [number, number];
     readonly molecule_largestFragment: (a: number) => [number, number, number];
     readonly molecule_nameOrEmpty: (a: number) => [number, number, number, number];
     readonly molecule_new: () => number;
     readonly molecule_numAtoms: (a: number) => number;
     readonly molecule_numBonds: (a: number) => number;
     readonly molecule_numConformers3d: (a: number) => number;
+    readonly molecule_perceiveStereochemistry: (a: number) => [number, number];
+    readonly molecule_potentialStereo: (a: number, b: any) => [number, number, number];
+    readonly molecule_potentialStereoWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_properties: (a: number) => number;
+    readonly molecule_property: (a: number, b: number, c: number) => any;
     readonly molecule_propertyKeys: (a: number) => [number, number, number, number];
     readonly molecule_propertyOrEmpty: (a: number, b: number, c: number) => [number, number, number, number];
-    readonly molecule_readMol: (a: number, b: number) => [number, number, number];
-    readonly molecule_readMol2: (a: number, b: number) => [number, number, number];
+    readonly molecule_readMol: (a: number, b: number, c: any) => [number, number, number];
+    readonly molecule_readMol2: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_readMol2WithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_readMolWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_readSdf: (a: number, b: number) => [number, number, number];
+    readonly molecule_readSdf: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_readSdfWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_readXyz: (a: number, b: number) => [number, number, number];
-    readonly molecule_removeHydrogens: (a: number) => [number, number];
-    readonly molecule_removeHydrogensWithParams: (a: number, b: any) => [number, number];
-    readonly molecule_sanitize: (a: number) => [number, number, number];
+    readonly molecule_removeHydrogensWithParams_: (a: number, b: any) => [number, number];
+    readonly molecule_removeHydrogens_: (a: number, b: any) => [number, number];
+    readonly molecule_sanitize: (a: number, b: any) => [number, number, number];
     readonly molecule_sanitizeWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_sanitizeWithParams_: (a: number, b: any) => [number, number];
-    readonly molecule_sanitize_: (a: number) => [number, number];
+    readonly molecule_sanitize_: (a: number, b: any) => [number, number];
     readonly molecule_sdfDataFieldNames: (a: number) => [number, number, number, number];
     readonly molecule_sdfDataFieldOrEmpty: (a: number, b: number, c: number) => [number, number, number, number];
-    readonly molecule_setAtomProperty: (a: number, b: any, c: number, d: number, e: any) => [number, number];
-    readonly molecule_toMol: (a: number) => [number, number, number, number];
+    readonly molecule_set2dCoordinatesWithParams_: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_set2dCoordinates_: (a: number, b: any, c: any) => [number, number];
+    readonly molecule_set3dCoordinatesWithParams_: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_set3dCoordinates_: (a: number, b: any, c: any) => [number, number];
+    readonly molecule_setAtomPositionWithParams_: (a: number, b: any, c: any, d: number) => [number, number];
+    readonly molecule_setAtomPosition_: (a: number, b: any, c: any, d: any) => [number, number];
+    readonly molecule_setAtomProperty_: (a: number, b: any, c: number, d: number, e: any) => [number, number];
+    readonly molecule_setOnly3dConformerWithParams_: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_setOnly3dConformer_: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_tetrahedralStereo: (a: number) => [number, number, number];
+    readonly molecule_toBuilder: (a: number) => number;
+    readonly molecule_toCxSmiles: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_toCxSmilesWithParams: (a: number, b: number) => [number, number, number, number];
+    readonly molecule_toFragmentCxSmiles: (a: number, b: any, c: any) => [number, number, number, number];
+    readonly molecule_toFragmentCxSmilesWithParams: (a: number, b: number) => [number, number, number, number];
+    readonly molecule_toFragmentSmiles: (a: number, b: any, c: any) => [number, number, number, number];
+    readonly molecule_toFragmentSmilesWithParams: (a: number, b: number) => [number, number, number, number];
+    readonly molecule_toMol: (a: number, b: any) => [number, number, number, number];
     readonly molecule_toMolWithParams: (a: number, b: any) => [number, number, number, number];
-    readonly molecule_toSdf: (a: number) => [number, number, number, number];
-    readonly molecule_toSdf2d: (a: number) => [number, number, number, number];
+    readonly molecule_toRandomSmiles: (a: number, b: any, c: any, d: any) => [number, number, number];
+    readonly molecule_toRandomSmilesWithParams: (a: number, b: any, c: any, d: number) => [number, number, number];
+    readonly molecule_toSdf: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_toSdf2d: (a: number, b: any) => [number, number, number, number];
     readonly molecule_toSdf2dWithParams: (a: number, b: any) => [number, number, number, number];
-    readonly molecule_toSdf3d: (a: number) => [number, number, number, number];
+    readonly molecule_toSdf3d: (a: number, b: any) => [number, number, number, number];
     readonly molecule_toSdf3dWithParams: (a: number, b: any) => [number, number, number, number];
     readonly molecule_toSdfWithParams: (a: number, b: any) => [number, number, number, number];
-    readonly molecule_toSmiles: (a: number) => [number, number, number, number];
-    readonly molecule_toXyz: (a: number) => [number, number, number, number];
+    readonly molecule_toSmiles: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_toSmilesWithParams: (a: number, b: number) => [number, number, number, number];
+    readonly molecule_toXyz: (a: number, b: any) => [number, number, number, number];
     readonly molecule_toXyzWithParams: (a: number, b: any) => [number, number, number, number];
-    readonly molecule_withAssignedAromaticity: (a: number) => [number, number, number];
+    readonly molecule_topology: (a: number) => number;
+    readonly molecule_with2dCoordinateBlock: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_with2dCoordinateBlockWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_with3dCoordinates: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_with3dCoordinatesWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_withAdded3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_withAdded3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_withAssignedAromaticity: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedAromaticityWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_withAssignedRadicals: (a: number) => [number, number, number];
-    readonly molecule_withAssignedRingFamilies: (a: number) => [number, number, number];
+    readonly molecule_withAssignedRingFamilies: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedRingFamiliesWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedRings: (a: number) => [number, number, number];
-    readonly molecule_withAssignedValence: (a: number) => [number, number, number];
+    readonly molecule_withAssignedValence: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedValenceWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_withAtomPosition: (a: number, b: any, c: any, d: any) => [number, number, number];
+    readonly molecule_withAtomPositionWithParams: (a: number, b: any, c: any, d: number) => [number, number, number];
     readonly molecule_withAtomProperty: (a: number, b: any, c: number, d: number, e: any) => [number, number, number];
-    readonly molecule_withHydrogens: (a: number) => [number, number, number];
+    readonly molecule_withChiralTagsFromStructure: (a: number, b: any) => [number, number, number];
+    readonly molecule_withChiralTagsFromStructureWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_withCipLabels: (a: number, b: any) => [number, number, number];
+    readonly molecule_withCipLabelsWithOptions: (a: number, b: number) => [number, number, number];
+    readonly molecule_withCleared3dConformers: (a: number) => [number, number, number];
+    readonly molecule_withHydrogens: (a: number, b: any) => [number, number, number];
     readonly molecule_withHydrogensWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_withKekulizedBonds: (a: number) => [number, number, number];
+    readonly molecule_withKekulizedBonds: (a: number, b: any) => [number, number, number];
     readonly molecule_withKekulizedBondsWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_withName: (a: number, b: number, c: number) => [number, number, number];
+    readonly molecule_withOnly3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_withOnly3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
     readonly molecule_withProperty: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly molecule_withSdfDataField: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-    readonly molecule_withoutHydrogens: (a: number) => [number, number, number];
+    readonly molecule_withoutHydrogens: (a: number, b: any) => [number, number, number];
     readonly molecule_withoutHydrogensWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_writeMol: (a: number, b: number, c: number) => [number, number];
+    readonly molecule_writeMol: (a: number, b: number, c: number, d: any) => [number, number];
     readonly molecule_writeMolWithParams: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly molecule_writeSdf: (a: number, b: number, c: number) => [number, number];
-    readonly molecule_writeSdfFiles: (a: number, b: number, c: number, d: any) => [number, number, number, number];
+    readonly molecule_writeSdf: (a: number, b: number, c: number, d: any) => [number, number];
+    readonly molecule_writeSdfFiles: (a: number, b: number, c: number, d: any, e: any) => [number, number, number, number];
     readonly molecule_writeSdfFilesWithParams: (a: number, b: number, c: number, d: any, e: any) => [number, number, number, number];
     readonly molecule_writeSdfWithParams: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly molecule_writeXyz: (a: number, b: number, c: number) => [number, number];
+    readonly molecule_writeXyz: (a: number, b: number, c: number, d: any) => [number, number];
     readonly molecule_writeXyzWithParams: (a: number, b: number, c: number, d: any) => [number, number];
     readonly moleculebatch_errorMode: (a: number) => number;
     readonly moleculebatch_errors: (a: number) => [number, number];
     readonly moleculebatch_fromDatasetIndices: (a: any, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fromRecords: (a: any, b: number) => [number, number, number];
-    readonly moleculebatch_fromSdfRecords: (a: number, b: number) => [number, number, number];
+    readonly moleculebatch_fromSdfRecords: (a: number, b: number, c: any) => [number, number, number];
     readonly moleculebatch_fromSdfRecordsWithParams: (a: number, b: number, c: any, d: any, e: any) => [number, number, number];
-    readonly moleculebatch_fromSmilesList: (a: any) => [number, number, number];
+    readonly moleculebatch_fromSmilesList: (a: any, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fromSmilesListWithParams: (a: any, b: number, c: number) => [number, number, number];
     readonly moleculebatch_get: (a: number, b: any) => [number, number, number];
     readonly moleculebatch_invalidCount: (a: number) => number;
@@ -1470,29 +2737,71 @@ export interface InitOutput {
     readonly moleculebatch_len: (a: number) => number;
     readonly moleculebatch_parallelJobs: (a: number) => any;
     readonly moleculebatch_progressBar: (a: number) => any;
-    readonly moleculebatch_readSdf: (a: number, b: number) => [number, number, number];
+    readonly moleculebatch_readSdf: (a: number, b: number, c: any) => [number, number, number];
     readonly moleculebatch_readSdfWithParams: (a: number, b: number, c: any, d: any, e: any, f: any) => [number, number, number];
     readonly moleculebatch_records: (a: number) => [number, number];
-    readonly moleculebatch_sanitize: (a: number) => [number, number, number];
+    readonly moleculebatch_sanitize: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_sanitizeWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly moleculebatch_toList: (a: number) => any;
-    readonly moleculebatch_toSmilesList: (a: number) => [number, number, number];
+    readonly moleculebatch_toSmilesList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_toSmilesListWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly moleculebatch_validCount: (a: number) => number;
     readonly moleculebatch_validMask: (a: number) => any;
-    readonly moleculebatch_withHydrogens: (a: number) => [number, number, number];
+    readonly moleculebatch_withHydrogens: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_withHydrogensWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_withKekulizedBonds: (a: number) => [number, number, number];
+    readonly moleculebatch_withKekulizedBonds: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_withKekulizedBondsWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly moleculebatch_withParallelJobs: (a: number, b: any) => [number, number, number];
     readonly moleculebatch_withProgressBar: (a: number, b: any) => [number, number, number];
     readonly moleculebatch_withValidRecords: (a: number) => number;
-    readonly moleculebatch_withoutHydrogens: (a: number) => [number, number, number];
+    readonly moleculebatch_withoutHydrogens: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_withoutHydrogensWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_writeSdf: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_writeSdfFiles: (a: number, b: number, c: number) => [number, number, number];
+    readonly moleculebatch_writeSdf: (a: number, b: number, c: number, d: any) => [number, number, number];
+    readonly moleculebatch_writeSdfFiles: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly moleculebatch_writeSdfFilesWithParams: (a: number, b: number, c: number, d: any, e: any, f: any) => [number, number, number];
     readonly moleculebatch_writeSdfWithParams: (a: number, b: number, c: number, d: any, e: any) => [number, number, number];
+    readonly moleculebuilder_add2dConformer: (a: number, b: any) => [number, number, number];
+    readonly moleculebuilder_add3dConformer: (a: number, b: any) => [number, number, number];
+    readonly moleculebuilder_addAtom: (a: number, b: number) => number;
+    readonly moleculebuilder_addBond: (a: number, b: number) => [number, number, number];
+    readonly moleculebuilder_addStereoGroup: (a: number, b: number) => [number, number, number];
+    readonly moleculebuilder_addSubstanceGroup: (a: number, b: number) => [number, number, number];
+    readonly moleculebuilder_atoms: (a: number) => any;
+    readonly moleculebuilder_bondBetweenAtoms: (a: number, b: any, c: any) => [number, number, number];
+    readonly moleculebuilder_bonds: (a: number) => any;
+    readonly moleculebuilder_build: (a: number) => [number, number, number];
+    readonly moleculebuilder_coordinates: (a: number) => number;
+    readonly moleculebuilder_degree: (a: number, b: any) => [number, number, number];
+    readonly moleculebuilder_fromParts: (a: number, b: number, c: number) => number;
+    readonly moleculebuilder_neighborBonds: (a: number, b: any) => [number, number, number];
+    readonly moleculebuilder_new: () => number;
+    readonly moleculebuilder_properties: (a: number) => number;
+    readonly moleculebuilder_removeBondBetweenAtoms: (a: number, b: any, c: any) => [number, number, number];
+    readonly moleculebuilder_set2dCoordinates: (a: number, b: any) => [number, number];
+    readonly moleculebuilder_setAtomFormalCharge: (a: number, b: any, c: any) => [number, number];
+    readonly moleculebuilder_setBondOrder: (a: number, b: any, c: any) => [number, number];
+    readonly moleculebuilder_stereoGroups: (a: number) => any;
+    readonly moleculebuilder_substanceGroups: (a: number) => any;
+    readonly moleculebuilder_withName: (a: number, b: number, c: number) => number;
+    readonly moleculebuilder_withProperties: (a: number, b: number) => number;
+    readonly moleculebuilder_withProperty: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+    readonly moleculebuilder_withSdfDataField: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly moleculeopspec_access: (a: number) => [number, number, number];
+    readonly moleculeopspec_autoRemap: (a: number) => number;
+    readonly moleculeopspec_cipState: (a: number) => [number, number];
+    readonly moleculeopspec_derivedEffects: (a: number) => [number, number, number];
+    readonly moleculeopspec_domain: (a: number) => [number, number];
+    readonly moleculeopspec_implFn: (a: number) => [number, number];
+    readonly moleculeopspec_ioRoundtrip: (a: number) => number;
+    readonly moleculeopspec_kind: (a: number) => [number, number];
+    readonly moleculeopspec_mayMutate: (a: number) => number;
+    readonly moleculeopspec_method: (a: number) => [number, number];
+    readonly moleculeopspec_output: (a: number) => [number, number];
+    readonly moleculeopspec_parity: (a: number) => number;
+    readonly moleculeopspec_requiresMapping: (a: number) => [number, number];
+    readonly moleculeopspec_resultType: (a: number) => [number, number];
+    readonly moleculeopspec_semanticPreconditions: (a: number) => number;
+    readonly moleculeopspec_status: (a: number) => number;
     readonly moleculeproperties_computedPropNames: (a: number) => [number, number, number];
     readonly moleculeproperties_isPropComputed: (a: number, b: number, c: number) => [number, number, number];
     readonly moleculeproperties_name: (a: number) => [number, number, number];
@@ -1511,6 +2820,46 @@ export interface InitOutput {
     readonly molwriteerror_threeD: (a: number) => any;
     readonly molwriteerror_twoD: (a: number) => any;
     readonly molwriteerror_valueDetail: (a: number) => any;
+    readonly operationInvariant: (a: number, b: number) => any;
+    readonly operationInvariantMatrix: () => any;
+    readonly operationParity: (a: number, b: number) => any;
+    readonly operationSpec: (a: number, b: number) => any;
+    readonly operationSpecs: () => any;
+    readonly operationerror_cause: (a: number) => [number, number, number];
+    readonly operationerror_domain: (a: number) => [number, number];
+    readonly operationerror_kind: (a: number) => [number, number];
+    readonly operationerror_message: (a: number) => [number, number];
+    readonly operationinvariantentry_operation: (a: number) => number;
+    readonly operationinvariantentry_profile: (a: number) => [number, number];
+    readonly parityMatrix: () => any;
+    readonly paritymatrixentry_feature: (a: number) => number;
+    readonly paritymatrixentry_operation: (a: number) => number;
+    readonly paritymatrixentry_profile: (a: number) => [number, number];
+    readonly paritymatrixentry_rdkitVersion: (a: number) => any;
+    readonly potentialstereocenter_index: (a: number) => number;
+    readonly potentialstereocenter_kind: (a: number) => [number, number];
+    readonly potentialstereoerror_cause: (a: number) => [number, number, number];
+    readonly potentialstereoerror_domain: (a: number) => [number, number];
+    readonly potentialstereoerror_kind: (a: number) => [number, number];
+    readonly potentialstereoerror_message: (a: number) => [number, number];
+    readonly potentialstereoinfo_centeredOn: (a: number) => number;
+    readonly potentialstereoinfo_controllingAtoms: (a: number) => any;
+    readonly potentialstereoinfo_descriptor: (a: number) => number;
+    readonly potentialstereoinfo_permutation: (a: number) => number;
+    readonly potentialstereoinfo_specified: (a: number) => number;
+    readonly potentialstereoinfo_stereoType: (a: number) => number;
+    readonly potentialstereoparams_allowNontetrahedral: (a: number) => number;
+    readonly potentialstereoparams_clean: (a: number) => number;
+    readonly potentialstereoparams_flagPossible: (a: number) => number;
+    readonly potentialstereoparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly potentialstereoparams_set_allowNontetrahedral: (a: number, b: any) => [number, number];
+    readonly potentialstereoparams_set_clean: (a: number, b: any) => [number, number];
+    readonly potentialstereoparams_set_flagPossible: (a: number, b: any) => [number, number];
+    readonly potentialstereoresult_atomRanks: (a: number) => any;
+    readonly potentialstereoresult_cleanedMolecule: (a: number) => any;
+    readonly potentialstereoresult_ringRelations: (a: number) => any;
+    readonly potentialstereoresult_stereo: (a: number) => any;
+    readonly propertyValueToText: (a: any) => [number, number, number, number];
     readonly propertystringerror_cause: (a: number) => any;
     readonly propertystringerror_domain: (a: number) => [number, number];
     readonly propertystringerror_kind: (a: number) => number;
@@ -1532,6 +2881,15 @@ export interface InitOutput {
     readonly querygraph_name: (a: number) => [number, number, number];
     readonly querygraph_numAtoms: (a: number) => number;
     readonly querygraph_numBonds: (a: number) => number;
+    readonly randomsmileswriteparams_allBondsExplicit: (a: number) => number;
+    readonly randomsmileswriteparams_allHydrogensExplicit: (a: number) => number;
+    readonly randomsmileswriteparams_isomericSmiles: (a: number) => number;
+    readonly randomsmileswriteparams_kekule: (a: number) => number;
+    readonly randomsmileswriteparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
+    readonly randomsmileswriteparams_set_allBondsExplicit: (a: number, b: any) => [number, number];
+    readonly randomsmileswriteparams_set_allHydrogensExplicit: (a: number, b: any) => [number, number];
+    readonly randomsmileswriteparams_set_isomericSmiles: (a: number, b: any) => [number, number];
+    readonly randomsmileswriteparams_set_kekule: (a: number, b: any) => [number, number];
     readonly removehsparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any, i: any, j: any, k: any, l: any, m: any, n: any, o: any, p: any, q: any) => [number, number, number];
     readonly removehsparams_removeAndTrackIsotopes: (a: number) => number;
     readonly removehsparams_removeDefiningBondStereo: (a: number) => number;
@@ -1548,11 +2906,36 @@ export interface InitOutput {
     readonly removehsparams_removeWithQuery: (a: number) => number;
     readonly removehsparams_removeWithWedgedBond: (a: number) => number;
     readonly removehsparams_sanitize: (a: number) => number;
+    readonly removehsparams_set_removeAndTrackIsotopes: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeDefiningBondStereo: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeDegreeZero: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeDummyNeighbors: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeHigherDegrees: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeHydrides: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeInSgroups: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeIsotopes: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeMapped: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeNonimplicit: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeNontetrahedralNeighbors: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeOnlyHNeighbors: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeWithQuery: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_removeWithWedgedBond: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_sanitize: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_showWarnings: (a: number, b: any) => [number, number];
+    readonly removehsparams_set_updateExplicitCount: (a: number, b: any) => [number, number];
     readonly removehsparams_showWarnings: (a: number) => number;
     readonly removehsparams_updateExplicitCount: (a: number) => number;
+    readonly replace3dcoordinatesparams_conformerId: (a: number) => number;
+    readonly replace3dcoordinatesparams_new: (a: any) => [number, number, number];
+    readonly replace3dcoordinatesparams_set_conformerId: (a: number, b: any) => [number, number];
     readonly ringsearchparams_includeDativeBonds: (a: number) => number;
     readonly ringsearchparams_includeHydrogenBonds: (a: number) => number;
     readonly ringsearchparams_new: (a: any, b: any) => [number, number, number];
+    readonly ringsearchparams_set_includeDativeBonds: (a: number, b: any) => [number, number];
+    readonly ringsearchparams_set_includeHydrogenBonds: (a: number, b: any) => [number, number];
+    readonly ringstereorelation_atom: (a: number) => number;
+    readonly ringstereorelation_other: (a: number) => number;
+    readonly ringstereorelation_sameOrientation: (a: number) => number;
     readonly sanitizeerror_bits: (a: number) => any;
     readonly sanitizeerror_cause: (a: number) => [number, number, number];
     readonly sanitizeerror_domain: (a: number) => [number, number];
@@ -1582,6 +2965,7 @@ export interface InitOutput {
     readonly sanitizeoperations_or: (a: number, b: number) => number;
     readonly sanitizeparams_new: (a: any) => [number, number, number];
     readonly sanitizeparams_operations: (a: number) => number;
+    readonly sanitizeparams_set_operations: (a: number, b: any) => [number, number];
     readonly sdfbatchiterator_next: (a: number) => [number, number, number];
     readonly sdfbatchiterator_nextBatch: (a: number) => [number, number, number];
     readonly sdfdataset_batches: (a: number, b: any, c: any, d: any, e: any) => [number, number, number];
@@ -1589,10 +2973,10 @@ export interface InitOutput {
     readonly sdfdataset_iter: (a: number) => any;
     readonly sdfdataset_len: (a: number) => number;
     readonly sdfdataset_metadata: (a: number, b: any) => [number, number, number];
-    readonly sdfdataset_open: (a: number, b: number) => [number, number, number];
+    readonly sdfdataset_open: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfdataset_openWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfdataset_path: (a: number) => [number, number];
-    readonly sdfdataset_record: (a: number, b: any) => [number, number, number];
+    readonly sdfdataset_record: (a: number, b: any, c: any) => [number, number, number];
     readonly sdfdataset_recordText: (a: number, b: any) => [number, number, number, number];
     readonly sdfdataset_recordWithParams: (a: number, b: any, c: any) => [number, number, number];
     readonly sdfdatasetiterator_next: (a: number) => [number, number, number];
@@ -1609,23 +2993,34 @@ export interface InitOutput {
     readonly sdfpropertylist_target: (a: number) => number;
     readonly sdfpropertylist_values: (a: number) => any;
     readonly sdfreader_batches: (a: number, b: any, c: any, d: any) => [number, number, number];
-    readonly sdfreader_open: (a: number, b: number) => [number, number, number];
+    readonly sdfreader_open: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfreader_openWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfreader_params: (a: number) => number;
     readonly sdfreader_path: (a: number) => [number, number];
     readonly sdfreaderbatchiterator_next: (a: number) => [number, number, number];
     readonly sdfreaderbatchiterator_nextBatch: (a: number) => [number, number, number];
+    readonly sdfreaderror_cause: (a: number) => any;
+    readonly sdfreaderror_context: (a: number) => any;
+    readonly sdfreaderror_domain: (a: number) => [number, number];
+    readonly sdfreaderror_kind: (a: number) => [number, number];
+    readonly sdfreaderror_message: (a: number) => [number, number];
     readonly sdfreadparams_coordinateMode: (a: number) => number;
     readonly sdfreadparams_expandAttachmentPoints: (a: number) => number;
     readonly sdfreadparams_new: (a: any, b: any, c: any, d: any, e: any, f: any) => [number, number, number];
     readonly sdfreadparams_processPropertyLists: (a: number) => number;
     readonly sdfreadparams_removeHs: (a: number) => number;
     readonly sdfreadparams_sanitize: (a: number) => number;
+    readonly sdfreadparams_set_coordinateMode: (a: number, b: any) => [number, number];
+    readonly sdfreadparams_set_expandAttachmentPoints: (a: number, b: any) => [number, number];
+    readonly sdfreadparams_set_processPropertyLists: (a: number, b: any) => [number, number];
+    readonly sdfreadparams_set_removeHs: (a: number, b: any) => [number, number];
+    readonly sdfreadparams_set_sanitize: (a: number, b: any) => [number, number];
+    readonly sdfreadparams_set_strictParsing: (a: number, b: any) => [number, number];
     readonly sdfreadparams_strictParsing: (a: number) => number;
     readonly sdfrecord_dataField: (a: number, b: number, c: number) => [number, number, number];
     readonly sdfrecord_dataFields: (a: number) => [number, number, number];
     readonly sdfrecord_fromQueryGraph: (a: any, b: any) => [number, number, number];
-    readonly sdfrecord_fromSdf: (a: number, b: number) => [number, number, number];
+    readonly sdfrecord_fromSdf: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfrecord_fromSdfWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfrecord_graph: (a: number) => number;
     readonly sdfrecord_index: (a: number) => number;
@@ -1635,9 +3030,9 @@ export interface InitOutput {
     readonly sdfrecord_sourceCoordinateDim: (a: number) => any;
     readonly sdfrecord_substanceGroups: (a: number) => any;
     readonly sdfrecord_title: (a: number) => [number, number, number];
-    readonly sdfrecord_toMol: (a: number) => [number, number, number, number];
+    readonly sdfrecord_toMol: (a: number, b: any) => [number, number, number, number];
     readonly sdfrecord_toMolWithParams: (a: number, b: any) => [number, number, number, number];
-    readonly sdfrecord_toSdf: (a: number) => [number, number, number, number];
+    readonly sdfrecord_toSdf: (a: number, b: any) => [number, number, number, number];
     readonly sdfrecord_toSdfWithParams: (a: number, b: any) => [number, number, number, number];
     readonly sdfrecordmetadata_byteLen: (a: number) => bigint;
     readonly sdfrecordmetadata_byteOffset: (a: number) => bigint;
@@ -1650,7 +3045,7 @@ export interface InitOutput {
     readonly sdfrecordstream_isEnd: (a: number) => number;
     readonly sdfrecordstream_linesConsumed: (a: number) => number;
     readonly sdfrecordstream_nextRecord: (a: number) => [number, number, number];
-    readonly sdfrecordstream_open: (a: number, b: number) => [number, number, number];
+    readonly sdfrecordstream_open: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfrecordstream_openWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly sdfrecordstream_recordsConsumed: (a: number) => number;
     readonly sgroupbracket_new: (a: any) => [number, number, number];
@@ -1670,8 +3065,25 @@ export interface InitOutput {
     readonly smilesparseparams_removeHs: (a: number) => number;
     readonly smilesparseparams_replacements: (a: number) => any;
     readonly smilesparseparams_sanitize: (a: number) => number;
+    readonly smilesparseparams_set_allowCxsmiles: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_debugParse: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_parseName: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_removeHs: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_replacements: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_sanitize: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_skipCleanup: (a: number, b: any) => [number, number];
+    readonly smilesparseparams_set_strictCxsmiles: (a: number, b: any) => [number, number];
     readonly smilesparseparams_skipCleanup: (a: number) => number;
     readonly smilesparseparams_strictCxsmiles: (a: number) => number;
+    readonly smilesstereoerror_actual: (a: number) => any;
+    readonly smilesstereoerror_cause: (a: number) => [number, number, number];
+    readonly smilesstereoerror_dimension: (a: number) => any;
+    readonly smilesstereoerror_domain: (a: number) => [number, number];
+    readonly smilesstereoerror_expected: (a: number) => any;
+    readonly smilesstereoerror_field: (a: number) => any;
+    readonly smilesstereoerror_id: (a: number) => any;
+    readonly smilesstereoerror_kind: (a: number) => [number, number];
+    readonly smilesstereoerror_message: (a: number) => [number, number];
     readonly smileswriteerror_cause: (a: number) => any;
     readonly smileswriteerror_domain: (a: number) => [number, number];
     readonly smileswriteerror_kind: (a: number) => [number, number];
@@ -1686,10 +3098,32 @@ export interface InitOutput {
     readonly smileswriteparams_kekule: (a: number) => number;
     readonly smileswriteparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any, i: any) => [number, number, number];
     readonly smileswriteparams_rootedAtAtom: (a: number) => any;
+    readonly smileswriteparams_set_allBondsExplicit: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_allHydrogensExplicit: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_canonical: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_cleanStereo: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_ignoreAtomMapNumbers: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_includeDativeBonds: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_isomericSmiles: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_kekule: (a: number, b: any) => [number, number];
+    readonly smileswriteparams_set_rootedAtAtom: (a: number, b: any) => [number, number];
+    readonly stereoerror_cause: (a: number) => [number, number, number];
+    readonly stereoerror_domain: (a: number) => [number, number];
+    readonly stereoerror_kind: (a: number) => [number, number];
+    readonly stereoerror_message: (a: number) => [number, number];
+    readonly stereogroup_atoms: (a: number) => any;
+    readonly stereogroup_bonds: (a: number) => any;
+    readonly stereogroup_kind: (a: number) => number;
+    readonly stereogroup_new: (a: any, b: any, c: any) => [number, number, number];
     readonly stereoreaderror_cause: (a: number) => any;
     readonly stereoreaderror_domain: (a: number) => [number, number];
     readonly stereoreaderror_kind: (a: number) => [number, number];
     readonly stereoreaderror_message: (a: number) => [number, number];
+    readonly structuretagparams_conformerId: (a: number) => number;
+    readonly structuretagparams_new: (a: any, b: any) => [number, number, number];
+    readonly structuretagparams_replaceExistingTags: (a: number) => number;
+    readonly structuretagparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly structuretagparams_set_replaceExistingTags: (a: number, b: any) => [number, number];
     readonly substancegroup_crossingBondCorrespondence: (a: number) => any;
     readonly substancegroup_cstates: (a: number) => any;
     readonly substancegroup_display: (a: number) => any;
@@ -1716,6 +3150,33 @@ export interface InitOutput {
     readonly substancegroupkind_Superatom: () => number;
     readonly substancegroupkind_equals: (a: number, b: number) => number;
     readonly substancegroupkind_genericValue: (a: number) => [number, number, number];
+    readonly supportMatrix: () => any;
+    readonly supportmatrixentry_feature: (a: number) => number;
+    readonly supportmatrixentry_operation: (a: number) => any;
+    readonly templateattachment_label: (a: number) => [number, number];
+    readonly templateattachment_new: (a: any, b: number, c: number) => [number, number, number];
+    readonly templateattachment_target: (a: number) => number;
+    readonly templateattachmentorder_entries: (a: number) => [number, number];
+    readonly templateattachmentorder_new: (a: any) => [number, number, number];
+    readonly templateattachmentordererror_atomCount: (a: number) => any;
+    readonly templateattachmentordererror_duplicatePosition: (a: number) => any;
+    readonly templateattachmentordererror_firstPosition: (a: number) => any;
+    readonly templateattachmentordererror_kind: (a: number) => [number, number];
+    readonly templateattachmentordererror_label: (a: number) => any;
+    readonly templateattachmentordererror_mappingLen: (a: number) => any;
+    readonly templateattachmentordererror_message: (a: number) => [number, number];
+    readonly templateattachmentordererror_position: (a: number) => any;
+    readonly templateattachmentordererror_target: (a: number) => any;
+    readonly tetrahedralstereo_center: (a: number) => number;
+    readonly tetrahedralstereo_ligands: (a: number) => any;
+    readonly topologyblock_atoms: (a: number) => any;
+    readonly topologyblock_bonds: (a: number) => any;
+    readonly topologyblock_stereoGroups: (a: number) => any;
+    readonly topologyblock_substanceGroups: (a: number) => any;
+    readonly transformerror_cause: (a: number) => [number, number, number];
+    readonly transformerror_domain: (a: number) => [number, number];
+    readonly transformerror_kind: (a: number) => [number, number];
+    readonly transformerror_message: (a: number) => [number, number];
     readonly valenceerror_atom: (a: number) => [number, number, number];
     readonly valenceerror_atomCount: (a: number) => [number, number, number];
     readonly valenceerror_atomicNumber: (a: number) => [number, number, number];
@@ -1742,6 +3203,8 @@ export interface InitOutput {
     readonly valenceerror_value: (a: number) => [number, number, number];
     readonly valenceparams_model: (a: number) => number;
     readonly valenceparams_new: (a: any, b: any) => [number, number, number];
+    readonly valenceparams_set_model: (a: number, b: any) => [number, number];
+    readonly valenceparams_set_strict: (a: number, b: any) => [number, number];
     readonly valenceparams_strict: (a: number) => number;
     readonly version: () => [number, number];
     readonly xyzreaderror_cause: (a: number) => any;
@@ -1758,26 +3221,56 @@ export interface InitOutput {
     readonly xyzwriteparams_conformerId: (a: number) => any;
     readonly xyzwriteparams_new: (a: any, b: any) => [number, number, number];
     readonly xyzwriteparams_precision: (a: number) => number;
-    readonly wasm_bindgen__convert__closures________invoke__h05828144f970d297: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h05828144f970d297_492: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h0ecdcf66e7de16f5: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h16053a9a5582d98a: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h2f6e3fbdaae669cd: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h2f6e3fbdaae669cd_501: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h3b07b94ba3385e87: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h3b07b94ba3385e87_466: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h3b07b94ba3385e87_516: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h4c0eb0ab39bb58ea: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h4ee291de6fd23bf5: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h5104340d32e7ecb2: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h5104340d32e7ecb2_500: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h5104340d32e7ecb2_537: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6fc2f97be6704299: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h8b74eb89454167b8: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h9b826f488ebcf650: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__haf3d3f0070555449: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hdbd904d44edc2d67: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hfa8880e47eceb021: (a: number, b: number, c: number) => void;
+    readonly xyzwriteparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly xyzwriteparams_set_precision: (a: number, b: any) => [number, number];
+    readonly wasm_bindgen__convert__closures________invoke__h041ac5624941c820: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h17356b03f701c7ed: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h199149965a7b00d0: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119_439: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119_528: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119_857: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119_859: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2030185edeab4119_917: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2034f5d62c3af59c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2034f5d62c3af59c_944: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2034f5d62c3af59c_945: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h25f77cfde9741188: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h27b399cb0907d6e0: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855_441: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855_529: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855_686: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855_860: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h29974995fc07e855_887: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2bfae6cc6287f397: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2fe9ddaffd8f73a2: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2fe9ddaffd8f73a2_438: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2fe9ddaffd8f73a2_440: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2fe9ddaffd8f73a2_762: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2fe9ddaffd8f73a2_775: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h316a017402b7e37f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h31f5d0a2e632d21a: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h4f4e8413ff407936: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h62a6c444a28a1722: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h62a6c444a28a1722_897: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h62a6c444a28a1722_898: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h6301bd1056d2a1b2: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h643cba485b8edde4: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357_275: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357_895: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357_896: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357_943: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h747a03697a341357_946: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h9176c75e5fea8006: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__ha5b58acb51da3f82: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd149408b1d7c8589: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd83dd081a1fa2068: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hee2db61edd29c007: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hf22a78f32c9b010a: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hff0aa86e7f633133: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hff8d8f3dfc48215c: (a: number, b: number, c: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;
@@ -1810,3 +3303,20 @@ export function initSync(module: { module: SyncInitInput } | SyncInitInput): Ini
  * @returns {Promise<InitOutput>}
  */
 export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
+
+/** Alias of `Molecule.fromSdf`. */
+export const molFromSdf: typeof Molecule.fromSdf;
+/** Alias of `Molecule.fromSmiles`. */
+export const molFromSmiles: typeof Molecule.fromSmiles;
+/** Alias of `Molecule.fromXyzBlock`. */
+export const molFromXyzBlock: typeof Molecule.fromXyzBlock;
+/** Alias of `Molecule.fromMol2`. */
+export const molFromMol2: typeof Molecule.fromMol2;
+/** Alias of `Molecule.fromMol`. */
+export const molFromMol: typeof Molecule.fromMol;
+/** Alias of `MoleculeBatch.fromSdfRecords`. */
+export const molsFromSdfRecords: typeof MoleculeBatch.fromSdfRecords;
+/** Alias of `MoleculeBatch.fromRecords`. */
+export const molsFromRecords: typeof MoleculeBatch.fromRecords;
+/** Alias of `MoleculeBatch.fromSmilesList`. */
+export const molsFromSmilesList: typeof MoleculeBatch.fromSmilesList;