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

package/wasm_wasm.d.ts

@@ -1,20 +1,411 @@
 /* tslint:disable */
 /* eslint-disable */
+export interface AddHsParamsOptions {
+    explicitOnly?: boolean;
+    addCoords?: boolean;
+    addResidueInfo?: boolean;
+    skipQueries?: boolean;
+    onlyOnAtoms?: number[] | Uint32Array | null;
+}
+
+
+export interface AlignmentParametersOptions {
+    probeConformerId?: number;
+    referenceConformerId?: number;
+    atomMap?: AlignmentAtomMap[] | null;
+    weights?: number[] | Float64Array | null;
+    reflect?: boolean;
+    maxIterations?: number;
+}
+
+
+export interface AllConformerRmsdParametersOptions {
+    atomMaps?: AlignmentAtomMap[][] | null;
+    weights?: number[] | Float64Array | null;
+    maxMatches?: number;
+    symmetrizeConjugatedTerminalGroups?: boolean;
+    ignoreHydrogens?: boolean;
+    numThreads?: number;
+}
+
+
+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 BestAlignmentParametersOptions {
+    probeConformerId?: number;
+    referenceConformerId?: number;
+    atomMaps?: AlignmentAtomMap[][] | null;
+    weights?: number[] | Float64Array | null;
+    reflect?: boolean;
+    maxIterations?: number;
+    maxMatches?: number;
+    symmetrizeConjugatedTerminalGroups?: boolean;
+    ignoreHydrogens?: boolean;
+    numThreads?: number;
+}
+
+
+export interface CipLabelOptionsOptions {
+    atoms?: number[] | null;
+    bonds?: number[] | null;
+    maxRecursiveIterations?: number;
+}
+
+
+export interface ConformerAlignmentParametersOptions {
+    atomIndices?: number[] | Uint32Array | null;
+    conformerIds?: number[] | Uint32Array | null;
+    weights?: number[] | Float64Array | null;
+    reflect?: boolean;
+    maxIterations?: number;
+}
+
+
+export interface Coordinate2DInputParamsOptions {
+    zPolicy?: CoordinateZPolicy | string;
+}
+
+
+export interface Coordinate3DInputParamsOptions {
+    is3d?: boolean;
+}
+
+
+export interface CoordinateRmsdParametersOptions {
+    probeConformerId?: number;
+    referenceConformerId?: number;
+    atomMaps?: AlignmentAtomMap[][] | null;
+    weights?: number[] | Float64Array | null;
+    maxMatches?: number;
+    symmetrizeConjugatedTerminalGroups?: 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 EmbedParamsOptions {
+    maxIterations?: number;
+    numThreads?: number;
+    randomSeed?: number;
+    clearConformers?: boolean;
+    useRandomCoords?: boolean;
+    boxSizeMult?: number;
+    randNegEig?: boolean;
+    numZeroFail?: number;
+    coordMap?: Map<number, number[] | Float64Array> | null;
+    optimizerForceTol?: number;
+    ignoreSmoothingFailures?: boolean;
+    enforceChirality?: boolean;
+    useExpTorsionAnglePrefs?: boolean;
+    useBasicKnowledge?: boolean;
+    verbose?: boolean;
+    basinThresh?: number;
+    pruneRmsThresh?: number;
+    onlyHeavyAtomsForRms?: boolean;
+    etVersion?: number;
+    embedFragmentsSeparately?: boolean;
+    useSmallRingTorsions?: boolean;
+    useMacrocycleTorsions?: boolean;
+    useMacrocycle14config?: boolean;
+    timeout?: number;
+    cpci?: Map<readonly [number, number], number> | null;
+    forceTransAmides?: boolean;
+    useSymmetryForPruning?: boolean;
+    boundsMatForceScaling?: number;
+    trackFailures?: boolean;
+    enableSequentialRandomSeeds?: boolean;
+    symmetrizeConjugatedTerminalGroupsForPruning?: boolean;
+}
+
+
+export interface ForceFieldMinimizeParamsOptions {
+    maxIterations?: number;
+    forceTolerance?: number;
+    energyTolerance?: number;
+}
+
+
+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 MmffConformerOptimizationParamsOptions {
+    numThreads?: number;
+    maxIterations?: number;
+    mmffVariant?: string;
+    nonBondedThreshold?: number;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface MmffEvaluationParamsOptions {
+    mmffVariant?: string;
+    nonBondedThreshold?: number;
+    conformerId?: number | null;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface MmffForceFieldParamsOptions {
+    conformerId?: number | null;
+    mmffVariant?: string;
+    nonBondedThreshold?: number;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface MmffOptimizationParamsOptions {
+    mmffVariant?: string;
+    maxIterations?: number;
+    nonBondedThreshold?: number;
+    conformerId?: number | null;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface MmffPropertiesParamsOptions {
+    mmffVariant?: string;
+}
+
+
+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 UffConformerOptimizationParamsOptions {
+    numThreads?: number;
+    maxIterations?: number;
+    vdwThreshold?: number;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface UffEvaluationParamsOptions {
+    vdwThreshold?: number;
+    conformerId?: number | null;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface UffForceFieldParamsOptions {
+    conformerId?: number | null;
+    vdwThreshold?: number;
+    ignoreInterfragmentInteractions?: boolean;
+}
+
+
+export interface UffOptimizationParamsOptions {
+    maxIterations?: number;
+    vdwThreshold?: number;
+    conformerId?: number | null;
+    ignoreInterfragmentInteractions?: 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 AlignmentAtomMap {
@@ -103,7 +494,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 {
@@ -126,10 +571,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 {
@@ -148,18 +593,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 {
@@ -204,6 +649,38 @@ export class BestAlignmentParameters {
     set weights(value: number[] | Float64Array | null);
 }
 
+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,
@@ -229,6 +706,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;
@@ -254,6 +748,81 @@ 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 ConformerAlignmentParameters {
     free(): void;
     [Symbol.dispose](): void;
@@ -304,11 +873,57 @@ export class ConformerRunError {
     readonly message: 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 CoordinateRmsdParameters {
     free(): void;
     [Symbol.dispose](): void;
@@ -324,6 +939,61 @@ export class CoordinateRmsdParameters {
     set weights(value: number[] | Float64Array | null);
 }
 
+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;
@@ -337,16 +1007,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 {
@@ -394,53 +1064,155 @@ export class EmbedMultipleConfsResult {
     requestedNumConfs(): number;
 }
 
-export class EmbedParams {
+export class EmbedParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(max_iterations?: number, num_threads?: number, random_seed?: number, clear_conformers?: boolean, use_random_coords?: boolean, box_size_mult?: number, rand_neg_eig?: boolean, num_zero_fail?: number, coord_map?: Map<number, number[] | Float64Array> | null, optimizer_force_tol?: number, ignore_smoothing_failures?: boolean, enforce_chirality?: boolean, use_exp_torsion_angle_prefs?: boolean, use_basic_knowledge?: boolean, verbose?: boolean, basin_thresh?: number, prune_rms_thresh?: number, only_heavy_atoms_for_rms?: boolean, et_version?: number, embed_fragments_separately?: boolean, use_small_ring_torsions?: boolean, use_macrocycle_torsions?: boolean, use_macrocycle14config?: boolean, timeout?: number, cpci?: Map<readonly [number, number], number> | null, force_trans_amides?: boolean, use_symmetry_for_pruning?: boolean, bounds_mat_force_scaling?: number, track_failures?: boolean, enable_sequential_random_seeds?: boolean, symmetrize_conjugated_terminal_groups_for_pruning?: boolean);
+    static dg(): EmbedParams;
+    static etdgV2(): EmbedParams;
+    static etdg(): EmbedParams;
+    static etkdgV2(): EmbedParams;
+    static etkdgV3(): EmbedParams;
+    static etkdg(): EmbedParams;
+    failures(): Uint32Array;
+    static kdg(): EmbedParams;
+    static new(): EmbedParams;
+    static srEtkdgV3(): EmbedParams;
+    toJson(): string;
+    withJson(json: string): EmbedParams;
+    basinThresh: number;
+    boundsMatForceScaling: number;
+    boxSizeMult: number;
+    clearConformers: boolean;
+    get coordMap(): Map<number, number[]> | null;
+    set coordMap(value: Map<number, number[] | Float64Array> | null);
+    cpci: Map<readonly [number, number], number> | null;
+    embedFragmentsSeparately: boolean;
+    enableSequentialRandomSeeds: boolean;
+    enforceChirality: boolean;
+    etVersion: number;
+    forceTransAmides: boolean;
+    ignoreSmoothingFailures: boolean;
+    maxIterations: number;
+    numThreads: number;
+    numZeroFail: number;
+    onlyHeavyAtomsForRms: boolean;
+    optimizerForceTol: number;
+    pruneRmsThresh: number;
+    randNegEig: boolean;
+    randomSeed: number;
+    symmetrizeConjugatedTerminalGroupsForPruning: boolean;
+    timeout: number;
+    trackFailures: boolean;
+    useBasicKnowledge: boolean;
+    useExpTorsionAnglePrefs: boolean;
+    useMacrocycle14config: boolean;
+    useMacrocycleTorsions: boolean;
+    useRandomCoords: boolean;
+    useSmallRingTorsions: boolean;
+    useSymmetryForPruning: boolean;
+    verbose: boolean;
+}
+
+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 ForceFieldEnergyGradient {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    energy(): number;
+    gradient(): number[][];
+}
+
+export class ForceFieldError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    actual(): number | null;
+    atomIndex(): number | null;
+    component(): number | null;
+    expected(): number | null;
+    kind(): MolecularForceFieldErrorKind;
+    requested(): number | null;
+    readonly cause: Error | null;
+    readonly message: string;
+}
+
+export class ForceFieldMinimizeOutcome {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    converged(): boolean;
+    energy(): number;
+    iterations(): number;
+}
+
+export class ForceFieldMinimizeParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(max_iterations?: number, force_tolerance?: number, energy_tolerance?: number);
+    energyTolerance: number;
+    forceTolerance: number;
+    maxIterations: number;
+}
+
+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;
-    basinThresh(): number;
-    boundsMatForceScaling(): number;
-    boxSizeMult(): number;
-    clearConformers(): boolean;
-    constructor(max_iterations?: number, num_threads?: number, random_seed?: number, clear_conformers?: boolean, use_random_coords?: boolean, box_size_mult?: number, rand_neg_eig?: boolean, num_zero_fail?: number, coord_map?: Map<number, number[] | Float64Array> | null, optimizer_force_tol?: number, ignore_smoothing_failures?: boolean, enforce_chirality?: boolean, use_exp_torsion_angle_prefs?: boolean, use_basic_knowledge?: boolean, verbose?: boolean, basin_thresh?: number, prune_rms_thresh?: number, only_heavy_atoms_for_rms?: boolean, et_version?: number, embed_fragments_separately?: boolean, use_small_ring_torsions?: boolean, use_macrocycle_torsions?: boolean, use_macrocycle14config?: boolean, timeout?: number, cpci?: Map<readonly [number, number], number> | null, force_trans_amides?: boolean, use_symmetry_for_pruning?: boolean, bounds_mat_force_scaling?: number, track_failures?: boolean, enable_sequential_random_seeds?: boolean, symmetrize_conjugated_terminal_groups_for_pruning?: boolean);
-    coordMap(): Map<number, number[]> | null;
-    cpci(): Map<readonly [number, number], number> | null;
-    static dg(): EmbedParams;
-    embedFragmentsSeparately(): boolean;
-    enableSequentialRandomSeeds(): boolean;
-    enforceChirality(): boolean;
-    etVersion(): number;
-    static etdgV2(): EmbedParams;
-    static etdg(): EmbedParams;
-    static etkdgV2(): EmbedParams;
-    static etkdgV3(): EmbedParams;
-    static etkdg(): EmbedParams;
-    failures(): Uint32Array;
-    forceTransAmides(): boolean;
-    ignoreSmoothingFailures(): boolean;
-    static kdg(): EmbedParams;
-    maxIterations(): number;
-    static new(): EmbedParams;
-    numThreads(): number;
-    numZeroFail(): number;
-    onlyHeavyAtomsForRms(): boolean;
-    optimizerForceTol(): number;
-    pruneRmsThresh(): number;
-    randNegEig(): boolean;
-    randomSeed(): number;
-    static srEtkdgV3(): EmbedParams;
-    symmetrizeConjugatedTerminalGroupsForPruning(): boolean;
-    timeout(): number;
-    toJson(): string;
-    trackFailures(): boolean;
-    useBasicKnowledge(): boolean;
-    useExpTorsionAnglePrefs(): boolean;
-    useMacrocycle14Config(): boolean;
-    useMacrocycleTorsions(): boolean;
-    useRandomCoords(): boolean;
-    useSmallRingTorsions(): boolean;
-    useSymmetryForPruning(): boolean;
-    verbose(): boolean;
-    withJson(json: string): EmbedParams;
+    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 {
@@ -481,9 +1253,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 {
@@ -520,11 +1300,11 @@ export class MmffConformerOptimizationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(num_threads?: number, max_iterations?: number, mmff_variant?: string, non_bonded_threshold?: number, ignore_interfragment_interactions?: boolean);
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly maxIterations: number;
-    readonly mmffVariant: string;
-    readonly nonBondedThreshold: number;
-    readonly numThreads: number;
+    ignoreInterfragmentInteractions: boolean;
+    maxIterations: number;
+    mmffVariant: string;
+    nonBondedThreshold: number;
+    numThreads: number;
 }
 
 export class MmffEnergyGradient {
@@ -539,10 +1319,34 @@ export class MmffEvaluationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(mmff_variant?: string, non_bonded_threshold?: number, conformer_id?: number | null, ignore_interfragment_interactions?: boolean);
-    readonly conformerId: number | null;
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly mmffVariant: string;
-    readonly nonBondedThreshold: number;
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    mmffVariant: string;
+    nonBondedThreshold: number;
+}
+
+export class MmffForceFieldError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    actual(): number | null;
+    atomIndex(): number | null;
+    component(): number | null;
+    expected(): number | null;
+    kind(): MolecularForceFieldErrorKind;
+    requested(): number | null;
+    readonly cause: Error | null;
+    readonly message: string;
+}
+
+export class MmffForceFieldParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(conformer_id?: number | null, mmff_variant?: string, non_bonded_threshold?: number, ignore_interfragment_interactions?: boolean);
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    mmffVariant: string;
+    nonBondedThreshold: number;
 }
 
 export class MmffMolPropertiesError {
@@ -567,11 +1371,11 @@ export class MmffOptimizationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(mmff_variant?: string, max_iterations?: number, non_bonded_threshold?: number, conformer_id?: number | null, ignore_interfragment_interactions?: boolean);
-    readonly conformerId: number | null;
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly maxIterations: number;
-    readonly mmffVariant: string;
-    readonly nonBondedThreshold: number;
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    maxIterations: number;
+    mmffVariant: string;
+    nonBondedThreshold: number;
 }
 
 export class MmffOptimizeMoleculeConfResult {
@@ -616,7 +1420,7 @@ export class MmffPropertiesParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(mmff_variant?: string);
-    readonly mmffVariant: string;
+    mmffVariant: string;
 }
 
 export enum MmffVariant {
@@ -651,10 +1455,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 {
@@ -665,13 +1469,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 {
@@ -702,6 +1506,41 @@ export class MolWriteError {
     readonly valueDetail: string | null;
 }
 
+export class MolecularForceField {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    energyGradient(): ForceFieldEnergyGradient;
+    energy(): number;
+    fixedAtoms(): number[];
+    gradientUnconstrained(): number[][];
+    gradient(): number[][];
+    minimizeWithParams_(params: ForceFieldMinimizeParams): ForceFieldMinimizeOutcome;
+    minimize_(params?: ForceFieldMinimizeParams | ForceFieldMinimizeParamsOptions): ForceFieldMinimizeOutcome;
+    position(atom_id: number): number[];
+    positions(): number[][];
+    setFixedAtoms_(atoms: number[] | Uint32Array): void;
+    setPosition_(atom_id: number, position: number[] | Float64Array): void;
+    setPositions_(positions: (number[] | Float64Array)[]): void;
+}
+
+export enum MolecularForceFieldErrorKind {
+    MissingConformer = 0,
+    Parameterization = 1,
+    InvalidParameterization = 2,
+    InvalidAtomIndex = 3,
+    InvalidFixedAtom = 4,
+    CoordinateCount = 5,
+    CoordinateShape = 6,
+    NonFiniteCoordinate = 7,
+    InvalidTolerance = 8,
+    Preparation = 9,
+    Construction = 10,
+    Initialization = 11,
+    Rings = 12,
+    Kernel = 13,
+}
+
 export class MolecularIoError {
     private constructor();
     free(): void;
@@ -728,89 +1567,105 @@ export class Molecule {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    addHydrogensWithParams(params: AddHsParams): void;
-    addHydrogens(): void;
-    alignConformersWithParams(params: ConformerAlignmentParameters): ConformerAlignmentReport;
-    alignConformers(): ConformerAlignmentReport;
-    alignToWithParams(reference: Molecule, params: AlignmentParameters): AlignmentResult;
-    alignTo(reference: Molecule): AlignmentResult;
+    add3dConformerWithParams_(coordinates: number[][], params: Coordinate3DInputParams): number;
+    add3dConformer_(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): number;
+    addHydrogensWithParams_(params: AddHsParams): void;
+    addHydrogens_(params?: AddHsParams | AddHsParamsOptions): void;
+    alignConformersWithParams_(params: ConformerAlignmentParameters): ConformerAlignmentReport;
+    alignConformers_(params?: ConformerAlignmentParameters | ConformerAlignmentParametersOptions): ConformerAlignmentReport;
+    alignToWithParams_(reference: Molecule, params: AlignmentParameters): AlignmentResult;
+    alignTo_(reference: Molecule, params?: AlignmentParameters | AlignmentParametersOptions): AlignmentResult;
     alignmentTransformToWithParams(reference: Molecule, params: AlignmentParameters): AlignmentResult;
-    alignmentTransformTo(reference: Molecule): AlignmentResult;
+    alignmentTransformTo(reference: Molecule, params?: AlignmentParameters | AlignmentParametersOptions): AlignmentResult;
     allConformerBestRmsdsWithParams(params: AllConformerRmsdParameters): ConformerRmsd[];
-    allConformerBestRmsds(): ConformerRmsd[];
-    assignAromaticityWithParams(params: AromaticityParams): void;
-    assignAromaticity(): void;
-    assignRadicals(): void;
-    assignRingFamiliesWithParams(params: RingSearchParams): void;
-    assignRingFamilies(): void;
-    assignRings(): void;
-    assignValenceWithParams(params: ValenceParams): void;
-    assignValence(): void;
+    allConformerBestRmsds(params?: AllConformerRmsdParameters | AllConformerRmsdParametersOptions): ConformerRmsd[];
+    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[];
     bestAlignmentToWithParams(reference: Molecule, params: BestAlignmentParameters): AlignmentResult;
-    bestAlignmentTo(reference: Molecule): AlignmentResult;
+    bestAlignmentTo(reference: Molecule, params?: BestAlignmentParameters | BestAlignmentParametersOptions): AlignmentResult;
     bestRmsdToWithParams(reference: Molecule, params: BestAlignmentParameters): number;
-    bestRmsdTo(reference: Molecule): number;
+    bestRmsdTo(reference: Molecule, params?: BestAlignmentParameters | BestAlignmentParametersOptions): number;
     bondPropertyString(id: number, key: string): string | null;
+    bond(index: number): Bond | null;
+    bonds(): Bond[];
+    cipComputed(): boolean;
+    clear3dConformers_(): void;
+    conformers3d(): Conformer3D[];
     coordinateRmsdToWithParams(reference: Molecule, params: CoordinateRmsdParameters): number;
-    coordinateRmsdTo(reference: Molecule): number;
+    coordinateRmsdTo(reference: Molecule, params?: CoordinateRmsdParameters | CoordinateRmsdParametersOptions): number;
     /**
      * 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;
     dgBoundsMatrix(): number[][];
     distanceMatrix3dWithParams(params: DistanceMatrix3dParams): DenseMatrix;
-    distanceMatrix3d(): DenseMatrix;
+    distanceMatrix3d(params?: DistanceMatrix3dParams | DistanceMatrix3dParamsOptions): DenseMatrix;
     distanceMatrixWithParams(params: DistanceMatrixParams): DenseMatrix;
-    distanceMatrix(): DenseMatrix;
-    embed3dConformerResultWithParams(params: EmbedParams): EmbedMoleculeResult;
-    embed3dConformerResult(): EmbedMoleculeResult;
-    embed3dConformerWithParams(params: EmbedParams): void;
-    embed3dConformer(): void;
-    embed3dConformersResultWithParams(num_confs: number, params: EmbedParams): EmbedMultipleConfsResult;
-    embed3dConformersResult(num_confs: number): EmbedMultipleConfsResult;
-    embed3dConformersWithParams(num_confs: number, params: EmbedParams): void;
-    embed3dConformers(num_confs: number): void;
+    distanceMatrix(params?: DistanceMatrixParams | DistanceMatrixParamsOptions): DenseMatrix;
+    embed3dConformerResultWithParams_(params: EmbedParams): EmbedMoleculeResult;
+    embed3dConformerResult_(params?: EmbedParams | EmbedParamsOptions): EmbedMoleculeResult;
+    embed3dConformerWithParams_(params: EmbedParams): void;
+    embed3dConformer_(params?: EmbedParams | EmbedParamsOptions): void;
+    embed3dConformersResultWithParams_(num_confs: number, params: EmbedParams): EmbedMultipleConfsResult;
+    embed3dConformersResult_(num_confs: number, params?: EmbedParams | EmbedParamsOptions): EmbedMultipleConfsResult;
+    embed3dConformersWithParams_(num_confs: number, params: EmbedParams): void;
+    embed3dConformers_(num_confs: number, params?: EmbedParams | EmbedParamsOptions): void;
     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.
      */
     largestFragment(): Molecule;
     mmffEnergyGradientWithParams(params: MmffEvaluationParams): MmffEnergyGradient | null;
-    mmffEnergyGradient(): MmffEnergyGradient | null;
+    mmffEnergyGradient(params?: MmffEvaluationParams | MmffEvaluationParamsOptions): MmffEnergyGradient | null;
+    mmffForceFieldWithParams(params: MmffForceFieldParams): MolecularForceField;
+    mmffForceField(params?: MmffForceFieldParams | MmffForceFieldParamsOptions): MolecularForceField;
     mmffHasAllMoleculeParams(): boolean;
     mmffPropertiesWithParams(params: MmffPropertiesParams): MmffProperties;
-    mmffProperties(): MmffProperties;
+    mmffProperties(params?: MmffPropertiesParams | MmffPropertiesParamsOptions): MmffProperties;
     /**
      * Returns the molecule name, or an empty string when no name is stored.
      */
@@ -832,6 +1687,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.
      */
@@ -841,19 +1700,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.
      */
@@ -862,60 +1722,97 @@ 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;
     uffEnergyGradientWithParams(params: UffEvaluationParams): UffEnergyGradient;
-    uffEnergyGradient(): UffEnergyGradient;
+    uffEnergyGradient(params?: UffEvaluationParams | UffEvaluationParamsOptions): UffEnergyGradient;
+    uffForceFieldWithParams(params: UffForceFieldParams): MolecularForceField;
+    uffForceField(params?: UffForceFieldParams | UffForceFieldParamsOptions): MolecularForceField;
     uffHasAllMoleculeParams(): boolean;
+    with2dCoordinateBlockWithParams(coordinates: number[][], params: Coordinate2DInputParams): Molecule;
+    with2dCoordinateBlock(coordinates: number[][], params?: Coordinate2DInputParams | Coordinate2DInputParamsOptions): Molecule;
     with3dConformerResultWithParams(params: EmbedParams): EmbedMoleculeResult;
-    with3dConformerResult(): EmbedMoleculeResult;
+    with3dConformerResult(params?: EmbedParams | EmbedParamsOptions): EmbedMoleculeResult;
     with3dConformerWithParams(params: EmbedParams): Molecule;
-    with3dConformer(): Molecule;
+    with3dConformer(params?: EmbedParams | EmbedParamsOptions): Molecule;
     with3dConformersResultWithParams(num_confs: number, params: EmbedParams): EmbedMultipleConfsResult;
-    with3dConformersResult(num_confs: number): EmbedMultipleConfsResult;
+    with3dConformersResult(num_confs: number, params?: EmbedParams | EmbedParamsOptions): EmbedMultipleConfsResult;
     with3dConformersWithParams(num_confs: number, params: EmbedParams): Molecule;
-    with3dConformers(num_confs: number): Molecule;
+    with3dConformers(num_confs: number, params?: EmbedParams | EmbedParamsOptions): 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;
     withAlignedConformersWithParams(params: ConformerAlignmentParameters): [Molecule, ConformerAlignmentReport];
-    withAlignedConformers(): [Molecule, ConformerAlignmentReport];
+    withAlignedConformers(params?: ConformerAlignmentParameters | ConformerAlignmentParametersOptions): [Molecule, ConformerAlignmentReport];
     withAlignmentToWithParams(reference: Molecule, params: AlignmentParameters): [Molecule, AlignmentResult];
-    withAlignmentTo(reference: Molecule): [Molecule, AlignmentResult];
+    withAlignmentTo(reference: Molecule, params?: AlignmentParameters | AlignmentParametersOptions): [Molecule, AlignmentResult];
     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;
     withMmffOptimizedConformersWithParams(params: MmffConformerOptimizationParams): MmffOptimizeMoleculeConfsResult;
-    withMmffOptimizedConformers(): MmffOptimizeMoleculeConfsResult;
+    withMmffOptimizedConformers(params?: MmffConformerOptimizationParams | MmffConformerOptimizationParamsOptions): MmffOptimizeMoleculeConfsResult;
     withMmffOptimizedWithParams(params: MmffOptimizationParams): MmffOptimizeMoleculeResult;
-    withMmffOptimized(): MmffOptimizeMoleculeResult;
+    withMmffOptimized(params?: MmffOptimizationParams | MmffOptimizationParamsOptions): MmffOptimizeMoleculeResult;
     /**
      * 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.
      */
@@ -925,19 +1822,19 @@ export class Molecule {
      */
     withSdfDataField(key: string, value: string): Molecule;
     withUffOptimizedConformersWithParams(params: UffConformerOptimizationParams): UffConformerOptimizationResult;
-    withUffOptimizedConformers(): UffConformerOptimizationResult;
+    withUffOptimizedConformers(params?: UffConformerOptimizationParams | UffConformerOptimizationParamsOptions): UffConformerOptimizationResult;
     withUffOptimizedWithParams(params: UffOptimizationParams): UffOptimizationResult;
-    withUffOptimized(): UffOptimizationResult;
+    withUffOptimized(params?: UffOptimizationParams | UffOptimizationParamsOptions): UffOptimizationResult;
     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 {
@@ -945,15 +1842,15 @@ export class MoleculeBatch {
     free(): void;
     [Symbol.dispose](): void;
     dgBoundsMatrixListWithParams(params: BatchQueryParams): (number[][] | null)[];
-    dgBoundsMatrixList(): (number[][] | null)[];
+    dgBoundsMatrixList(params?: BatchQueryParams | BatchQueryParamsOptions): (number[][] | null)[];
     errorMode(): BatchErrorMode;
     errors(): BatchError[];
     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[];
@@ -962,28 +1859,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 {
@@ -999,6 +1949,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;
@@ -1054,35 +2113,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 {
@@ -1134,10 +2219,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;
@@ -1152,7 +2237,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 {
@@ -1195,11 +2281,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 {
@@ -1249,16 +2335,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 {
@@ -1267,7 +2367,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;
 }
@@ -1288,7 +2388,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;
@@ -1298,9 +2398,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 {
@@ -1325,7 +2425,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;
 }
 
@@ -1343,14 +2443,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 {
@@ -1367,15 +2483,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 {
@@ -1388,6 +2529,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;
@@ -1432,14 +2581,80 @@ 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 UffConformerOptimizationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(num_threads?: number, max_iterations?: number, vdw_threshold?: number, ignore_interfragment_interactions?: boolean);
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly maxIterations: number;
-    readonly numThreads: number;
-    readonly vdwThreshold: number;
+    ignoreInterfragmentInteractions: boolean;
+    maxIterations: number;
+    numThreads: number;
+    vdwThreshold: number;
 }
 
 export class UffConformerOptimizationResult {
@@ -1472,9 +2687,28 @@ export class UffEvaluationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(vdw_threshold?: number, conformer_id?: number | null, ignore_interfragment_interactions?: boolean);
-    readonly conformerId: number | null;
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly vdwThreshold: number;
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    vdwThreshold: number;
+}
+
+export class UffForceFieldError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    kind(): MolecularForceFieldErrorKind;
+    requested(): number | null;
+    readonly cause: Error | null;
+    readonly message: string;
+}
+
+export class UffForceFieldParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(conformer_id?: number | null, vdw_threshold?: number, ignore_interfragment_interactions?: boolean);
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    vdwThreshold: number;
 }
 
 export class UffOptimizationError {
@@ -1499,10 +2733,10 @@ export class UffOptimizationParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(max_iterations?: number, vdw_threshold?: number, conformer_id?: number | null, ignore_interfragment_interactions?: boolean);
-    readonly conformerId: number | null;
-    readonly ignoreInterfragmentInteractions: boolean;
-    readonly maxIterations: number;
-    readonly vdwThreshold: number;
+    conformerId: number | null;
+    ignoreInterfragmentInteractions: boolean;
+    maxIterations: number;
+    vdwThreshold: number;
 }
 
 export class UffOptimizationResult {
@@ -1578,8 +2812,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 {
@@ -1609,12 +2843,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.
  */
@@ -1633,6 +2887,10 @@ export interface InitOutput {
     readonly __wbg_allconformerrmsdparameters_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;
@@ -1641,15 +2899,31 @@ export interface InitOutput {
     readonly __wbg_batchrecord_free: (a: number, b: number) => void;
     readonly __wbg_batchvalidationerror_free: (a: number, b: number) => void;
     readonly __wbg_bestalignmentparameters_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_conformeralignmentparameters_free: (a: number, b: number) => void;
     readonly __wbg_conformeralignmentreport_free: (a: number, b: number) => void;
     readonly __wbg_conformererror_free: (a: number, b: number) => void;
     readonly __wbg_conformerrmsd_free: (a: number, b: number) => void;
     readonly __wbg_conformerrunerror_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_coordinatermsdparameters_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;
@@ -1658,14 +2932,26 @@ export interface InitOutput {
     readonly __wbg_embedmoleculeresult_free: (a: number, b: number) => void;
     readonly __wbg_embedmultipleconfsresult_free: (a: number, b: number) => void;
     readonly __wbg_embedparams_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_forcefieldenergygradient_free: (a: number, b: number) => void;
+    readonly __wbg_forcefielderror_free: (a: number, b: number) => void;
+    readonly __wbg_forcefieldminimizeoutcome_free: (a: number, b: number) => void;
+    readonly __wbg_forcefieldminimizeparams_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_mmffatomproperties_free: (a: number, b: number) => void;
     readonly __wbg_mmffconformeroptimizationparams_free: (a: number, b: number) => void;
     readonly __wbg_mmffenergygradient_free: (a: number, b: number) => void;
     readonly __wbg_mmffevaluationparams_free: (a: number, b: number) => void;
+    readonly __wbg_mmffforcefielderror_free: (a: number, b: number) => void;
+    readonly __wbg_mmffforcefieldparams_free: (a: number, b: number) => void;
     readonly __wbg_mmffmolpropertieserror_free: (a: number, b: number) => void;
     readonly __wbg_mmffoptimizationerror_free: (a: number, b: number) => void;
     readonly __wbg_mmffoptimizationparams_free: (a: number, b: number) => void;
@@ -1679,17 +2965,31 @@ export interface InitOutput {
     readonly __wbg_mol2readparams_free: (a: number, b: number) => void;
     readonly __wbg_molblockwriteparams_free: (a: number, b: number) => void;
     readonly __wbg_molcoordinateselection_free: (a: number, b: number) => void;
+    readonly __wbg_molecularforcefield_free: (a: number, b: number) => void;
     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;
@@ -1701,6 +3001,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;
@@ -1710,17 +3011,30 @@ 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_uffconformeroptimizationparams_free: (a: number, b: number) => void;
     readonly __wbg_uffconformeroptimizationresult_free: (a: number, b: number) => void;
     readonly __wbg_uffconformerresult_free: (a: number, b: number) => void;
     readonly __wbg_uffenergygradient_free: (a: number, b: number) => void;
     readonly __wbg_uffevaluationparams_free: (a: number, b: number) => void;
+    readonly __wbg_uffforcefielderror_free: (a: number, b: number) => void;
+    readonly __wbg_uffforcefieldparams_free: (a: number, b: number) => void;
     readonly __wbg_uffoptimizationerror_free: (a: number, b: number) => void;
     readonly __wbg_uffoptimizationerrorkind_free: (a: number, b: number) => void;
     readonly __wbg_uffoptimizationparams_free: (a: number, b: number) => void;
@@ -1737,6 +3051,11 @@ 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 alignmentatommap_constructor: (a: any, b: any) => [number, number, number];
     readonly alignmentatommap_new: (a: any, b: any) => [number, number, number];
@@ -1785,7 +3104,40 @@ export interface InitOutput {
     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;
@@ -1796,6 +3148,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;
@@ -1804,12 +3160,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;
@@ -1843,6 +3205,23 @@ export interface InitOutput {
     readonly bestalignmentparameters_set_weights: (a: number, b: any) => [number, number];
     readonly bestalignmentparameters_symmetrizeConjugatedTerminalGroups: (a: number) => number;
     readonly bestalignmentparameters_weights: (a: number) => any;
+    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;
@@ -1850,6 +3229,28 @@ 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 conformeralignmentparameters_atomIndices: (a: number) => any;
     readonly conformeralignmentparameters_conformerIds: (a: number) => any;
     readonly conformeralignmentparameters_constructor: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
@@ -1873,6 +3274,25 @@ export interface InitOutput {
     readonly conformerrunerror_cause: (a: number) => any;
     readonly conformerrunerror_domain: (a: number) => [number, number];
     readonly conformerrunerror_message: (a: 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 coordinatermsdparameters_atomMaps: (a: number) => any;
     readonly coordinatermsdparameters_constructor: (a: any, b: any, c: any, d: any, e: any, f: any) => [number, number, number];
     readonly coordinatermsdparameters_maxMatches: (a: number) => number;
@@ -1887,13 +3307,51 @@ export interface InitOutput {
     readonly coordinatermsdparameters_set_weights: (a: number, b: any) => [number, number];
     readonly coordinatermsdparameters_symmetrizeConjugatedTerminalGroups: (a: number) => number;
     readonly coordinatermsdparameters_weights: (a: number) => any;
+    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;
@@ -1948,6 +3406,37 @@ export interface InitOutput {
     readonly embedparams_pruneRmsThresh: (a: number) => number;
     readonly embedparams_randNegEig: (a: number) => number;
     readonly embedparams_randomSeed: (a: number) => number;
+    readonly embedparams_set_basinThresh: (a: number, b: any) => [number, number];
+    readonly embedparams_set_boundsMatForceScaling: (a: number, b: any) => [number, number];
+    readonly embedparams_set_boxSizeMult: (a: number, b: any) => [number, number];
+    readonly embedparams_set_clearConformers: (a: number, b: any) => [number, number];
+    readonly embedparams_set_coordMap: (a: number, b: any) => [number, number];
+    readonly embedparams_set_cpci: (a: number, b: any) => [number, number];
+    readonly embedparams_set_embedFragmentsSeparately: (a: number, b: any) => [number, number];
+    readonly embedparams_set_enableSequentialRandomSeeds: (a: number, b: any) => [number, number];
+    readonly embedparams_set_enforceChirality: (a: number, b: any) => [number, number];
+    readonly embedparams_set_etVersion: (a: number, b: any) => [number, number];
+    readonly embedparams_set_forceTransAmides: (a: number, b: any) => [number, number];
+    readonly embedparams_set_ignoreSmoothingFailures: (a: number, b: any) => [number, number];
+    readonly embedparams_set_maxIterations: (a: number, b: any) => [number, number];
+    readonly embedparams_set_numThreads: (a: number, b: any) => [number, number];
+    readonly embedparams_set_numZeroFail: (a: number, b: any) => [number, number];
+    readonly embedparams_set_onlyHeavyAtomsForRms: (a: number, b: any) => [number, number];
+    readonly embedparams_set_optimizerForceTol: (a: number, b: any) => [number, number];
+    readonly embedparams_set_pruneRmsThresh: (a: number, b: any) => [number, number];
+    readonly embedparams_set_randNegEig: (a: number, b: any) => [number, number];
+    readonly embedparams_set_randomSeed: (a: number, b: any) => [number, number];
+    readonly embedparams_set_symmetrizeConjugatedTerminalGroupsForPruning: (a: number, b: any) => [number, number];
+    readonly embedparams_set_timeout: (a: number, b: any) => [number, number];
+    readonly embedparams_set_trackFailures: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useBasicKnowledge: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useExpTorsionAnglePrefs: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useMacrocycle14config: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useMacrocycleTorsions: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useRandomCoords: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useSmallRingTorsions: (a: number, b: any) => [number, number];
+    readonly embedparams_set_useSymmetryForPruning: (a: number, b: any) => [number, number];
+    readonly embedparams_set_verbose: (a: number, b: any) => [number, number];
     readonly embedparams_srEtkdgV3: () => number;
     readonly embedparams_symmetrizeConjugatedTerminalGroupsForPruning: (a: number) => number;
     readonly embedparams_timeout: (a: number) => number;
@@ -1955,13 +3444,64 @@ export interface InitOutput {
     readonly embedparams_trackFailures: (a: number) => number;
     readonly embedparams_useBasicKnowledge: (a: number) => number;
     readonly embedparams_useExpTorsionAnglePrefs: (a: number) => number;
-    readonly embedparams_useMacrocycle14Config: (a: number) => number;
+    readonly embedparams_useMacrocycle14config: (a: number) => number;
     readonly embedparams_useMacrocycleTorsions: (a: number) => number;
     readonly embedparams_useRandomCoords: (a: number) => number;
     readonly embedparams_useSmallRingTorsions: (a: number) => number;
     readonly embedparams_useSymmetryForPruning: (a: number) => number;
     readonly embedparams_verbose: (a: number) => number;
     readonly embedparams_withJson: (a: number, b: number, c: number) => [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 forcefieldenergygradient_energy: (a: number) => number;
+    readonly forcefieldenergygradient_gradient: (a: number) => any;
+    readonly forcefielderror_actual: (a: number) => any;
+    readonly forcefielderror_atomIndex: (a: number) => any;
+    readonly forcefielderror_cause: (a: number) => any;
+    readonly forcefielderror_component: (a: number) => any;
+    readonly forcefielderror_expected: (a: number) => any;
+    readonly forcefielderror_kind: (a: number) => number;
+    readonly forcefielderror_message: (a: number) => [number, number];
+    readonly forcefielderror_requested: (a: number) => any;
+    readonly forcefieldminimizeoutcome_converged: (a: number) => number;
+    readonly forcefieldminimizeoutcome_energy: (a: number) => number;
+    readonly forcefieldminimizeoutcome_iterations: (a: number) => number;
+    readonly forcefieldminimizeparams_energyTolerance: (a: number) => number;
+    readonly forcefieldminimizeparams_forceTolerance: (a: number) => number;
+    readonly forcefieldminimizeparams_maxIterations: (a: number) => number;
+    readonly forcefieldminimizeparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly forcefieldminimizeparams_set_energyTolerance: (a: number, b: any) => [number, number];
+    readonly forcefieldminimizeparams_set_forceTolerance: (a: number, b: any) => [number, number];
+    readonly forcefieldminimizeparams_set_maxIterations: (a: number, b: any) => [number, number];
+    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];
@@ -1988,6 +3528,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];
@@ -2012,6 +3558,11 @@ export interface InitOutput {
     readonly mmffconformeroptimizationparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
     readonly mmffconformeroptimizationparams_nonBondedThreshold: (a: number) => number;
     readonly mmffconformeroptimizationparams_numThreads: (a: number) => number;
+    readonly mmffconformeroptimizationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly mmffconformeroptimizationparams_set_maxIterations: (a: number, b: any) => [number, number];
+    readonly mmffconformeroptimizationparams_set_mmffVariant: (a: number, b: any) => [number, number];
+    readonly mmffconformeroptimizationparams_set_nonBondedThreshold: (a: number, b: any) => [number, number];
+    readonly mmffconformeroptimizationparams_set_numThreads: (a: number, b: any) => [number, number];
     readonly mmffenergygradient_energy: (a: number) => number;
     readonly mmffenergygradient_gradient: (a: number) => any;
     readonly mmffevaluationparams_conformerId: (a: number) => any;
@@ -2019,6 +3570,27 @@ export interface InitOutput {
     readonly mmffevaluationparams_mmffVariant: (a: number) => [number, number];
     readonly mmffevaluationparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
     readonly mmffevaluationparams_nonBondedThreshold: (a: number) => number;
+    readonly mmffevaluationparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly mmffevaluationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly mmffevaluationparams_set_mmffVariant: (a: number, b: any) => [number, number];
+    readonly mmffevaluationparams_set_nonBondedThreshold: (a: number, b: any) => [number, number];
+    readonly mmffforcefielderror_actual: (a: number) => any;
+    readonly mmffforcefielderror_atomIndex: (a: number) => any;
+    readonly mmffforcefielderror_cause: (a: number) => any;
+    readonly mmffforcefielderror_component: (a: number) => any;
+    readonly mmffforcefielderror_expected: (a: number) => any;
+    readonly mmffforcefielderror_kind: (a: number) => number;
+    readonly mmffforcefielderror_message: (a: number) => [number, number];
+    readonly mmffforcefielderror_requested: (a: number) => any;
+    readonly mmffforcefieldparams_conformerId: (a: number) => any;
+    readonly mmffforcefieldparams_ignoreInterfragmentInteractions: (a: number) => number;
+    readonly mmffforcefieldparams_mmffVariant: (a: number) => [number, number];
+    readonly mmffforcefieldparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
+    readonly mmffforcefieldparams_nonBondedThreshold: (a: number) => number;
+    readonly mmffforcefieldparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly mmffforcefieldparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly mmffforcefieldparams_set_mmffVariant: (a: number, b: any) => [number, number];
+    readonly mmffforcefieldparams_set_nonBondedThreshold: (a: number, b: any) => [number, number];
     readonly mmffmolpropertieserror_cause: (a: number) => any;
     readonly mmffmolpropertieserror_domain: (a: number) => [number, number];
     readonly mmffmolpropertieserror_kind: (a: number) => [number, number];
@@ -2031,6 +3603,11 @@ export interface InitOutput {
     readonly mmffoptimizationparams_mmffVariant: (a: number) => [number, number];
     readonly mmffoptimizationparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
     readonly mmffoptimizationparams_nonBondedThreshold: (a: number) => number;
+    readonly mmffoptimizationparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly mmffoptimizationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly mmffoptimizationparams_set_maxIterations: (a: number, b: any) => [number, number];
+    readonly mmffoptimizationparams_set_mmffVariant: (a: number, b: any) => [number, number];
+    readonly mmffoptimizationparams_set_nonBondedThreshold: (a: number, b: any) => [number, number];
     readonly mmffoptimizemoleculeconfresult_energy: (a: number) => number;
     readonly mmffoptimizemoleculeconfresult_needsMore: (a: number) => number;
     readonly mmffoptimizemoleculeconfresult_statusCode: (a: number) => number;
@@ -2047,6 +3624,7 @@ export interface InitOutput {
     readonly mmffproperties_variant: (a: number) => number;
     readonly mmffpropertiesparams_mmffVariant: (a: number) => [number, number];
     readonly mmffpropertiesparams_new: (a: any) => [number, number, number];
+    readonly mmffpropertiesparams_set_mmffVariant: (a: number, b: any) => [number, number];
     readonly mol2posterror_cause: (a: number) => any;
     readonly mol2posterror_domain: (a: number) => [number, number];
     readonly mol2posterror_kind: (a: number) => [number, number];
@@ -2062,6 +3640,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;
@@ -2071,11 +3653,30 @@ 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];
     readonly molcoordinateselection_id: (a: number) => any;
     readonly molcoordinateselection_kind: (a: number) => [number, number];
+    readonly molecularforcefield_energy: (a: number) => [number, number, number];
+    readonly molecularforcefield_energyGradient: (a: number) => [number, number, number];
+    readonly molecularforcefield_fixedAtoms: (a: number) => any;
+    readonly molecularforcefield_gradient: (a: number) => [number, number, number];
+    readonly molecularforcefield_gradientUnconstrained: (a: number) => [number, number, number];
+    readonly molecularforcefield_minimizeWithParams_: (a: number, b: number) => [number, number, number];
+    readonly molecularforcefield_minimize_: (a: number, b: any) => [number, number, number];
+    readonly molecularforcefield_position: (a: number, b: any) => [number, number, number];
+    readonly molecularforcefield_positions: (a: number) => any;
+    readonly molecularforcefield_setFixedAtoms_: (a: number, b: any) => [number, number];
+    readonly molecularforcefield_setPosition_: (a: number, b: any, c: any) => [number, number];
+    readonly molecularforcefield_setPositions_: (a: number, b: any) => [number, number];
     readonly molecularioerror_cause: (a: number) => any;
     readonly molecularioerror_coordinateId: (a: number) => any;
     readonly molecularioerror_coordinateKind: (a: number) => any;
@@ -2092,70 +3693,89 @@ 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_alignConformers: (a: number) => [number, number, number];
-    readonly molecule_alignConformersWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_alignTo: (a: number, b: number) => [number, number, number];
-    readonly molecule_alignToWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly molecule_alignmentTransformTo: (a: number, b: number) => [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_alignConformersWithParams_: (a: number, b: number) => [number, number, number];
+    readonly molecule_alignConformers_: (a: number, b: any) => [number, number, number];
+    readonly molecule_alignToWithParams_: (a: number, b: number, c: number) => [number, number, number];
+    readonly molecule_alignTo_: (a: number, b: number, c: any) => [number, number, number];
+    readonly molecule_alignmentTransformTo: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_alignmentTransformToWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly molecule_allConformerBestRmsds: (a: number) => [number, number, number, number];
+    readonly molecule_allConformerBestRmsds: (a: number, b: any) => [number, number, number, number];
     readonly molecule_allConformerBestRmsdsWithParams: (a: number, b: number) => [number, number, 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_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_bestAlignmentTo: (a: number, b: number) => [number, number, number];
+    readonly molecule_atoms: (a: number) => [number, number];
+    readonly molecule_bestAlignmentTo: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_bestAlignmentToWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly molecule_bestRmsdTo: (a: number, b: number) => [number, number, number];
+    readonly molecule_bestRmsdTo: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_bestRmsdToWithParams: (a: number, b: number, c: number) => [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_coordinateRmsdTo: (a: number, b: 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_coordinateRmsdTo: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_coordinateRmsdToWithParams: (a: number, b: number, c: number) => [number, number, number];
     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_dgBoundsMatrix: (a: number) => [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_embed3dConformer: (a: number) => [number, number];
-    readonly molecule_embed3dConformerResult: (a: number) => [number, number, number];
-    readonly molecule_embed3dConformerResultWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_embed3dConformerWithParams: (a: number, b: number) => [number, number];
-    readonly molecule_embed3dConformers: (a: number, b: any) => [number, number];
-    readonly molecule_embed3dConformersResult: (a: number, b: any) => [number, number, number];
-    readonly molecule_embed3dConformersResultWithParams: (a: number, b: any, c: number) => [number, number, number];
-    readonly molecule_embed3dConformersWithParams: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_embed3dConformerResultWithParams_: (a: number, b: number) => [number, number, number];
+    readonly molecule_embed3dConformerResult_: (a: number, b: any) => [number, number, number];
+    readonly molecule_embed3dConformerWithParams_: (a: number, b: number) => [number, number];
+    readonly molecule_embed3dConformer_: (a: number, b: any) => [number, number];
+    readonly molecule_embed3dConformersResultWithParams_: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_embed3dConformersResult_: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_embed3dConformersWithParams_: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_embed3dConformers_: (a: number, b: any, c: any) => [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_mmffEnergyGradient: (a: number) => [number, number, number];
+    readonly molecule_mmffEnergyGradient: (a: number, b: any) => [number, number, number];
     readonly molecule_mmffEnergyGradientWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_mmffForceField: (a: number, b: any) => [number, number, number];
+    readonly molecule_mmffForceFieldWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_mmffHasAllMoleculeParams: (a: number) => [number, number, number];
-    readonly molecule_mmffProperties: (a: number) => [number, number, number];
+    readonly molecule_mmffProperties: (a: number, b: any) => [number, number, number];
     readonly molecule_mmffPropertiesWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_nameOrEmpty: (a: number) => [number, number, number, number];
     readonly molecule_new: () => number;
@@ -2163,93 +3783,135 @@ export interface InitOutput {
     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_uffEnergyGradient: (a: number) => [number, number, number];
+    readonly molecule_topology: (a: number) => number;
+    readonly molecule_uffEnergyGradient: (a: number, b: any) => [number, number, number];
     readonly molecule_uffEnergyGradientWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_uffForceField: (a: number, b: any) => [number, number, number];
+    readonly molecule_uffForceFieldWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_uffHasAllMoleculeParams: (a: number) => [number, number, number];
-    readonly molecule_with3dConformer: (a: number) => [number, number, number];
-    readonly molecule_with3dConformerResult: (a: number) => [number, 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_with3dConformer: (a: number, b: any) => [number, number, number];
+    readonly molecule_with3dConformerResult: (a: number, b: any) => [number, number, number];
     readonly molecule_with3dConformerResultWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_with3dConformerWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_with3dConformers: (a: number, b: any) => [number, number, number];
-    readonly molecule_with3dConformersResult: (a: number, b: any) => [number, number, number];
+    readonly molecule_with3dConformers: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_with3dConformersResult: (a: number, b: any, c: any) => [number, number, number];
     readonly molecule_with3dConformersResultWithParams: (a: number, b: any, c: number) => [number, number, number];
     readonly molecule_with3dConformersWithParams: (a: number, b: any, c: number) => [number, number, number];
-    readonly molecule_withAlignedConformers: (a: 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_withAlignedConformers: (a: number, b: any) => [number, number, number];
     readonly molecule_withAlignedConformersWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_withAlignmentTo: (a: number, b: number) => [number, number, number];
+    readonly molecule_withAlignmentTo: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_withAlignmentToWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly molecule_withAssignedAromaticity: (a: 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_withMmffOptimized: (a: number) => [number, number, number];
-    readonly molecule_withMmffOptimizedConformers: (a: number) => [number, number, number];
+    readonly molecule_withMmffOptimized: (a: number, b: any) => [number, number, number];
+    readonly molecule_withMmffOptimizedConformers: (a: number, b: any) => [number, number, number];
     readonly molecule_withMmffOptimizedConformersWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_withMmffOptimizedWithParams: (a: number, b: number) => [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_withUffOptimized: (a: number) => [number, number, number];
-    readonly molecule_withUffOptimizedConformers: (a: number) => [number, number, number];
+    readonly molecule_withUffOptimized: (a: number, b: any) => [number, number, number];
+    readonly molecule_withUffOptimizedConformers: (a: number, b: any) => [number, number, number];
     readonly molecule_withUffOptimizedConformersWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_withUffOptimizedWithParams: (a: number, b: 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_dgBoundsMatrixList: (a: number) => [number, number, number];
+    readonly moleculebatch_dgBoundsMatrixList: (a: number, b: any) => [number, number, number];
     readonly moleculebatch_dgBoundsMatrixListWithParams: (a: number, b: number) => [number, 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;
@@ -2258,29 +3920,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];
@@ -2299,6 +4003,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;
@@ -2320,6 +4064,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;
@@ -2336,11 +4089,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];
@@ -2370,6 +4148,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];
@@ -2377,10 +4156,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];
@@ -2397,23 +4176,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;
@@ -2423,9 +4213,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;
@@ -2438,7 +4228,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];
@@ -2458,8 +4248,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];
@@ -2474,10 +4281,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;
@@ -2504,10 +4333,41 @@ 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 uffconformeroptimizationparams_ignoreInterfragmentInteractions: (a: number) => number;
     readonly uffconformeroptimizationparams_maxIterations: (a: number) => number;
     readonly uffconformeroptimizationparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
     readonly uffconformeroptimizationparams_numThreads: (a: number) => number;
+    readonly uffconformeroptimizationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly uffconformeroptimizationparams_set_maxIterations: (a: number, b: any) => [number, number];
+    readonly uffconformeroptimizationparams_set_numThreads: (a: number, b: any) => [number, number];
+    readonly uffconformeroptimizationparams_set_vdwThreshold: (a: number, b: any) => [number, number];
     readonly uffconformeroptimizationparams_vdwThreshold: (a: number) => number;
     readonly uffconformeroptimizationresult_conformerResults: (a: number) => any;
     readonly uffconformeroptimizationresult_molecule: (a: number) => number;
@@ -2520,7 +4380,21 @@ export interface InitOutput {
     readonly uffevaluationparams_conformerId: (a: number) => any;
     readonly uffevaluationparams_ignoreInterfragmentInteractions: (a: number) => number;
     readonly uffevaluationparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly uffevaluationparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly uffevaluationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly uffevaluationparams_set_vdwThreshold: (a: number, b: any) => [number, number];
     readonly uffevaluationparams_vdwThreshold: (a: number) => number;
+    readonly uffforcefielderror_cause: (a: number) => any;
+    readonly uffforcefielderror_kind: (a: number) => number;
+    readonly uffforcefielderror_message: (a: number) => [number, number];
+    readonly uffforcefielderror_requested: (a: number) => any;
+    readonly uffforcefieldparams_conformerId: (a: number) => any;
+    readonly uffforcefieldparams_ignoreInterfragmentInteractions: (a: number) => number;
+    readonly uffforcefieldparams_new: (a: any, b: any, c: any) => [number, number, number];
+    readonly uffforcefieldparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly uffforcefieldparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly uffforcefieldparams_set_vdwThreshold: (a: number, b: any) => [number, number];
+    readonly uffforcefieldparams_vdwThreshold: (a: number) => number;
     readonly uffoptimizationerror_cause: (a: number) => any;
     readonly uffoptimizationerror_kind: (a: number) => number;
     readonly uffoptimizationerror_message: (a: number) => [number, number];
@@ -2531,6 +4405,10 @@ export interface InitOutput {
     readonly uffoptimizationparams_ignoreInterfragmentInteractions: (a: number) => number;
     readonly uffoptimizationparams_maxIterations: (a: number) => number;
     readonly uffoptimizationparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
+    readonly uffoptimizationparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly uffoptimizationparams_set_ignoreInterfragmentInteractions: (a: number, b: any) => [number, number];
+    readonly uffoptimizationparams_set_maxIterations: (a: number, b: any) => [number, number];
+    readonly uffoptimizationparams_set_vdwThreshold: (a: number, b: any) => [number, number];
     readonly uffoptimizationparams_vdwThreshold: (a: number) => number;
     readonly uffoptimizationresult_energy: (a: number) => number;
     readonly uffoptimizationresult_molecule: (a: number) => number;
@@ -2569,6 +4447,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;
@@ -2585,26 +4465,72 @@ 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__h02dd5bb1596fa437: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h112f2b94b395c3b6: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h112f2b94b395c3b6_791: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h112f2b94b395c3b6_828: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h11f2cb6aab050246: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h28200ff0948fe19f: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h3bb8276473513294: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h63a6ad0400842691: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6c0d3b8d469de4fc: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h741270caa5180b2c: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h741270caa5180b2c_792: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h92cd66da3cd821da: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h9c6323f252f31333: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h9c6323f252f31333_783: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__ha22180313638548a: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hc603d81e3c27533b: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hc603d81e3c27533b_658: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hc603d81e3c27533b_807: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hcf2c820d9f44e791: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hff5338322b4b27f8: (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__h007e449f1d8b7767: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h007e449f1d8b7767_459: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h007e449f1d8b7767_461: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h007e449f1d8b7767_859: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h007e449f1d8b7767_977: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162_1087: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162_1315: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162_460: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162_626: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h00c605a1a4eec162_782: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h01954f3f416abc61: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h05c2b857ca39c0ad: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0a6a9e15eb4fe90e: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0e62d208bc85753d: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0ebfca127b086b0c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c_1325: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c_1326: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c_1371: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c_1374: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1d71f41f26c1328c_278: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h23f28f18ad0a8cf6: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2a95aa3c7ba91340: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2a95aa3c7ba91340_1159: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2a95aa3c7ba91340_1198: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2a95aa3c7ba91340_1199: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2a95aa3c7ba91340_1200: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2c6809950f56132e: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25_1085: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25_1086: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25_1345: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25_462: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h33e6a6cc85558a25_625: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h35571db85ad7ac41: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3d733cf528485170: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3d733cf528485170_1240: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h46f2ec1692767c7b: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h46f2ec1692767c7b_1372: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h46f2ec1692767c7b_1373: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h4aa8badf1b6439ba: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h4e36ba6741882caa: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h4edafbb972309c66: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h5ec8c6ffe97968f0: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h6df6811b9ac26c5b: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h714b863b48d9f6cc: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h72a1a0c1ad86174d: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h7b73270678d507a6: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h7ce2a38f7964b093: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h7f794c48beedc80c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h94bf5c25aa51c9cd: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h94bf5c25aa51c9cd_1323: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h94bf5c25aa51c9cd_1324: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h9baf87dc39959464: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__ha71e96b3ea0b0625: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__ha8620ce4da2d4fa9: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hbbd39294c4ad281f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hcdb034d518699736: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd034de8bfd4c109d: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd964b835401ab21f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hdee76fde1494b76a: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hdfb7a8c88ebbb76f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__he82348240f5b1dad: (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;
@@ -2637,3 +4563,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;