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

package/wasm_wasm.d.ts

@@ -1,5 +1,54 @@
 /* tslint:disable */
 /* eslint-disable */
+export interface AddHsParamsOptions {
+    explicitOnly?: boolean;
+    addCoords?: boolean;
+    addResidueInfo?: boolean;
+    skipQueries?: boolean;
+    onlyOnAtoms?: number[] | Uint32Array | null;
+}
+
+
+export interface AromaticityParamsOptions {
+    model?: AromaticityModel | null;
+}
+
+
+export interface AtomPairAtomInvariantsGeneratorOptions {
+    includeChirality?: boolean;
+    topologicalTorsionCorrection?: boolean;
+}
+
+
+export interface AtomPairFingerprintParamsOptions {
+    generator?: AtomPairParams | null;
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+    customBondInvariants?: number[] | Uint32Array | null;
+    conformerId?: number;
+    atomInvariantsGenerator?: AtomPairAtomInvariantsGenerator | null;
+    useLegacyStereoPerception?: boolean;
+}
+
+
+export interface AtomPairParamsOptions {
+    minDistance?: number;
+    maxDistance?: number;
+    includeChirality?: boolean;
+    use2d?: boolean;
+    countSimulation?: boolean;
+    fpSize?: number;
+    bitsPerFeature?: number;
+    countBounds?: number[] | Uint32Array | null;
+}
+
+
+export interface AtomPositionParamsOptions {
+    conformerId?: number | null;
+}
+
+
 export interface AvalonFingerprintOptions {
     nBits?: number;
     isQuery?: boolean;
@@ -7,6 +56,89 @@ export interface AvalonFingerprintOptions {
 }
 
 
+export interface BatchExportParamsOptions {
+    format?: SdfFormat;
+    errors?: BatchErrorMode | null;
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+}
+
+
+export interface BatchParamsOptions {
+    errors?: BatchErrorMode | null;
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+}
+
+
+export interface BatchQueryParamsOptions {
+    nJobs?: number | null;
+    progressBar?: boolean | null;
+    progressCallback?: (() => void) | null;
+}
+
+
+export interface CipLabelOptionsOptions {
+    atoms?: number[] | null;
+    bonds?: number[] | null;
+    maxRecursiveIterations?: number;
+}
+
+
+export interface Coordinate2DInputParamsOptions {
+    zPolicy?: CoordinateZPolicy | string;
+}
+
+
+export interface Coordinate3DInputParamsOptions {
+    is3d?: boolean;
+}
+
+
+export interface CxSmilesWriteParamsOptions {
+    smiles?: SmilesWriteParams | SmilesWriteParamsOptions;
+    fields?: CxSmilesFields;
+    coordinateSelection?: CxCoordinateSelection;
+}
+
+
+export interface DistanceMatrix3dParamsOptions {
+    conformerId?: number | null;
+    useAtomWeights?: boolean;
+}
+
+
+export interface DistanceMatrixParamsOptions {
+    useBondOrder?: boolean;
+    useAtomWeights?: boolean;
+}
+
+
+export interface FragmentCxSmilesWriteParamsOptions {
+    atoms?: number[];
+    cx?: CxSmilesWriteParams | CxSmilesWriteParamsOptions;
+    bonds?: number[] | null;
+    atomSymbols?: string[] | null;
+    bondSymbols?: string[] | null;
+}
+
+
+export interface FragmentSmilesWriteParamsOptions {
+    atoms?: number[];
+    smiles?: SmilesWriteParams | SmilesWriteParamsOptions;
+    bonds?: number[] | null;
+    atomSymbols?: string[] | null;
+    bondSymbols?: string[] | null;
+}
+
+
+export interface KekulizeParamsOptions {
+    markAtomsBonds?: boolean;
+    canonical?: boolean;
+    maxBacktracks?: number;
+}
+
+
 export interface LayeredFingerprintOptions {
     layers?: number;
     minPath?: number;
@@ -19,6 +151,22 @@ export interface LayeredFingerprintOptions {
 }
 
 
+export interface LegacyTopologicalTorsionParamsOptions {
+    torsionAtomCount?: number;
+    includeChirality?: boolean;
+    fpSize?: number;
+    bitsPerEntry?: number;
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+}
+
+
+export interface MaccsFingerprintParamsOptions {
+    nBits?: number;
+}
+
+
 export interface McsAtomCompareParametersOptions {
     matchValences?: boolean;
     matchChiralTag?: boolean;
@@ -53,11 +201,188 @@ export interface McsParametersOptions {
 }
 
 
+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 MorganBondInvariantsGeneratorOptions {
+    useBondTypes?: boolean;
+    includeChirality?: boolean;
+}
+
+
+export interface MorganCallParamsOptions {
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+    customBondInvariants?: number[] | Uint32Array | null;
+    conformerId?: number;
+}
+
+
+export interface MorganFingerprintParamsOptions {
+    generator?: MorganParams | null;
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+    customBondInvariants?: number[] | Uint32Array | null;
+    conformerId?: number;
+    invariants?: MorganInvariants | null;
+}
+
+
+export interface MorganParamsOptions {
+    radius?: number;
+    includeChirality?: boolean;
+    useBondTypes?: boolean;
+    includeRingMembership?: boolean;
+    onlyNonzeroInvariants?: boolean;
+    includeRedundantEnvironments?: boolean;
+    fpSize?: number;
+    countSimulation?: boolean;
+    countBounds?: number[] | Uint32Array | null;
+    bitsPerFeature?: number;
+}
+
+
+export interface PatternFingerprintParamsOptions {
+    nBits?: number;
+    tautomeric?: 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 SmartsParseParamsOptions {
+    allowCxsmiles?: boolean;
+    strictCxsmiles?: boolean;
+    parseName?: boolean;
+    mergeHs?: boolean;
+    skipCleanup?: boolean;
+    debugParse?: boolean;
+    replacements?: Map<string, string> | Record<string, string> | null;
+}
+
+
+export interface SmartsWriteParamsOptions {
+    includeAtomMaps?: boolean;
+    isomericSmiles?: boolean;
+    includeDativeBonds?: boolean;
+    rootedAtAtom?: number | null;
+}
+
+
+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 SubstructMatchOptions {
     maxMatches?: number;
     uniquify?: boolean;
@@ -75,6 +400,75 @@ export interface SubstructMatchOptions {
     extraAtomCheckOverridesDefaultCheck?: boolean;
     extraBondCheckOverridesDefaultCheck?: boolean;
     useGenericMatchers?: boolean;
+    finalMatch?: ((target: Molecule, atoms: number[]) => boolean) | null;
+    atomMatch?: ((query: QueryAtom, target: Atom) => boolean) | null;
+    bondMatch?: ((query: Bond, target: Bond) => boolean) | null;
+}
+
+
+export interface TopologicalFingerprintOutputRequestOptions {
+    atomBits?: boolean;
+    bitInfo?: boolean;
+}
+
+
+export interface TopologicalFingerprintParamsOptions {
+    minPath?: number;
+    maxPath?: number;
+    fpSize?: number;
+    numBitsPerFeature?: number;
+    useHs?: boolean;
+    targetDensity?: number;
+    minSize?: number;
+    branchedPaths?: boolean;
+    useBondOrder?: boolean;
+    atomInvariants?: number[] | Uint32Array | null;
+    fromAtoms?: number[] | Uint32Array | null;
+}
+
+
+export interface TopologicalTorsionCallParamsOptions {
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+    customBondInvariants?: number[] | Uint32Array | null;
+    conformerId?: number;
+    useLegacyStereoPerception?: boolean;
+}
+
+
+export interface TopologicalTorsionFingerprintParamsOptions {
+    generator?: TopologicalTorsionParams | null;
+    fromAtoms?: number[] | Uint32Array | null;
+    ignoreAtoms?: number[] | Uint32Array | null;
+    customAtomInvariants?: number[] | Uint32Array | null;
+    customBondInvariants?: number[] | Uint32Array | null;
+    conformerId?: number;
+    atomInvariantsGenerator?: AtomPairAtomInvariantsGenerator | null;
+    useLegacyStereoPerception?: boolean;
+}
+
+
+export interface TopologicalTorsionParamsOptions {
+    torsionAtomCount?: number;
+    onlyShortestPaths?: boolean;
+    includeChirality?: boolean;
+    countSimulation?: boolean;
+    fpSize?: number;
+    bitsPerFeature?: number;
+    countBounds?: number[] | Uint32Array | null;
+}
+
+
+export interface ValenceParamsOptions {
+    model?: ValenceModel;
+    strict?: boolean;
+}
+
+
+export interface XyzWriteParamsOptions {
+    conformerId?: number | null;
+    precision?: number;
 }
 
 
@@ -83,11 +477,12 @@ export class AddHsParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(explicit_only?: boolean, add_coords?: boolean, add_residue_info?: boolean, skip_queries?: boolean, only_on_atoms?: number[] | Uint32Array | null);
-    readonly addCoords: boolean;
-    readonly addResidueInfo: boolean;
-    readonly explicitOnly: boolean;
-    readonly onlyOnAtoms: number[] | null;
-    readonly skipQueries: boolean;
+    addCoords: boolean;
+    addResidueInfo: boolean;
+    explicitOnly: boolean;
+    get onlyOnAtoms(): number[] | null;
+    set onlyOnAtoms(value: number[] | Uint32Array | null);
+    skipQueries: boolean;
 }
 
 export class AromaticityError {
@@ -112,7 +507,32 @@ 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 AtomCodeExplanation {
@@ -137,6 +557,17 @@ export class AtomCodeExplanationError {
     readonly message: string;
 }
 
+export class AtomMetadata {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    degree(): number;
+    explicitValence(): number;
+    implicitHydrogens(): number;
+    totalHydrogens(): number;
+    totalValence(): number;
+}
+
 export class AtomPairAtomCodeResult {
     private constructor();
     free(): void;
@@ -151,22 +582,27 @@ export class AtomPairAtomInvariantsGenerator {
     infoString(): string;
     constructor(include_chirality?: boolean, topological_torsion_correction?: boolean);
     toJson(): string;
-    readonly includeChirality: boolean;
-    readonly topologicalTorsionCorrection: boolean;
+    includeChirality: boolean;
+    topologicalTorsionCorrection: boolean;
 }
 
 export class AtomPairFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(generator?: AtomPairParams | null, from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number, atom_invariants_generator?: AtomPairAtomInvariantsGenerator | null, use_legacy_stereo_perception?: boolean);
-    readonly atomInvariantsGenerator: AtomPairAtomInvariantsGenerator | null;
-    readonly conformerId: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly customBondInvariants: number[] | null;
-    readonly fromAtoms: number[] | null;
-    readonly generator: AtomPairParams;
-    readonly ignoreAtoms: number[] | null;
-    readonly useLegacyStereoPerception: boolean;
+    atomInvariantsGenerator: AtomPairAtomInvariantsGenerator | null;
+    conformerId: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    get customBondInvariants(): number[] | null;
+    set customBondInvariants(value: number[] | Uint32Array | null);
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get generator(): AtomPairParams;
+    set generator(value: AtomPairParams | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
+    useLegacyStereoPerception: boolean;
 }
 
 export class AtomPairParams {
@@ -176,14 +612,15 @@ export class AtomPairParams {
     constructor(min_distance?: number, max_distance?: number, include_chirality?: boolean, use_2d?: boolean, count_simulation?: boolean, fp_size?: number, bits_per_feature?: number, count_bounds?: number[] | Uint32Array | null);
     toJson(): string;
     withJson(json: string): AtomPairParams;
-    readonly bitsPerFeature: number;
-    readonly countBounds: number[];
-    readonly countSimulation: boolean;
-    readonly fpSize: number;
-    readonly includeChirality: boolean;
-    readonly maxDistance: number;
-    readonly minDistance: number;
-    readonly use2d: boolean;
+    bitsPerFeature: number;
+    get countBounds(): number[];
+    set countBounds(value: number[] | Uint32Array | null);
+    countSimulation: boolean;
+    fpSize: number;
+    includeChirality: boolean;
+    maxDistance: number;
+    minDistance: number;
+    use2d: boolean;
 }
 
 export class AtomPairReadError {
@@ -212,6 +649,24 @@ export class AtomPairsParameters {
     static version(): string;
 }
 
+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 AvalonEngineError {
     private constructor();
     free(): void;
@@ -270,10 +725,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 {
@@ -321,18 +776,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 {
@@ -358,6 +813,38 @@ export class BatchValidationError {
     readonly recordErrors: BatchError[];
 }
 
+export class Bond {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    begin(): number;
+    cipDescriptor(): CipDescriptor | null;
+    cipNeighborOrder(): number[] | null;
+    directionCode(): number;
+    directionName(): string;
+    direction(): BondDirection;
+    end(): number;
+    id(): number;
+    isAromatic(): boolean;
+    orderCode(): number;
+    orderName(): string;
+    order(): BondOrder;
+    stereoAtoms(): number[] | null;
+    stereoCode(): number;
+    stereoName(): string;
+    stereo(): BondStereo;
+}
+
+export enum BondDirection {
+    None = 0,
+    BeginWedge = 1,
+    BeginDash = 2,
+    EndDownRight = 3,
+    EndUpRight = 4,
+    EitherDouble = 5,
+    Unknown = 6,
+}
+
 export enum BondOrder {
     Unspecified = 0,
     Single = 1,
@@ -383,6 +870,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;
@@ -408,6 +912,62 @@ 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 CipRankError {
     private constructor();
     free(): void;
@@ -428,27 +988,147 @@ export class CipRankError {
     readonly value: number | bigint | null;
 }
 
-export class CompiledQuery {
+export class CompiledQuery {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    atomOrder(): number[];
+    numAtoms(): number;
+    numBonds(): number;
+    query(): QueryGraph;
+}
+
+export class Conformer2D {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coordinates(): [number, number][];
+    id(): number;
+    props(): Map<string, string>;
+}
+
+export class Conformer3D {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coordinates(): [number, number, number][];
+    id(): number;
+    is3d(): boolean;
+    props(): Map<string, string>;
+}
+
+export class Coordinate2DInputParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(z_policy?: CoordinateZPolicy | string);
+    get zPolicy(): CoordinateZPolicy;
+    set zPolicy(value: CoordinateZPolicy | string);
+}
+
+export class Coordinate3DInputParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(is_3d?: boolean);
+    is3d: boolean;
+}
+
+export class Coordinate3DReadError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly conformerId: number;
+    readonly count: number;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class CoordinateBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly conformers2d: Conformer2D[];
+    readonly conformers3d: Conformer3D[];
+    readonly sourceConformerOrder: CoordinateDimension[] | null;
+    readonly sourceCoordinateDim: CoordinateDimension | null;
+}
+
+export enum CoordinateDimension {
+    TwoD = 0,
+    ThreeD = 1,
+}
+
+export class CoordinateInputError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
+export class CoordinateZPolicy {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static fromName(value: string): CoordinateZPolicy;
+    static readonly Error: CoordinateZPolicy;
+    static readonly Ignore: CoordinateZPolicy;
+    static readonly RequireZero: CoordinateZPolicy;
+}
+
+export class CrippenTotals {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    atomOrder(): number[];
-    numAtoms(): number;
-    numBonds(): number;
-    query(): QueryGraph;
+    readonly logp: number;
+    readonly molarRefractivity: number;
 }
 
-export enum CoordinateDimension {
-    TwoD = 0,
-    ThreeD = 1,
+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 CrippenTotals {
+export class CxSmilesFields {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    readonly logp: number;
-    readonly molarRefractivity: number;
+    bits(): number;
+    contains(other: CxSmilesFields): boolean;
+    or(other: CxSmilesFields): CxSmilesFields;
+    static readonly ALL: CxSmilesFields;
+    static readonly ALL_BUT_COORDS: 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 {
@@ -498,16 +1178,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 {
@@ -534,6 +1214,22 @@ export class ElementInfo {
     valences(): Int32Array;
 }
 
+export class FeatureSpec {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly category: string;
+    readonly docs: string;
+    readonly name: string;
+}
+
+export class FeatureSpecIter {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    next(): FeatureSpec | null;
+}
+
 export class Fingerprint {
     private constructor();
     free(): void;
@@ -592,6 +1288,51 @@ export class FingerprintPreparationError {
     readonly message: string;
 }
 
+export class FragmentCxSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atoms?: number[], cx?: CxSmilesWriteParams | CxSmilesWriteParamsOptions, bonds?: number[] | null, atom_symbols?: string[] | null, bond_symbols?: string[] | null);
+    atomSymbols: string[] | null;
+    atoms: number[];
+    bondSymbols: string[] | null;
+    bonds: number[] | null;
+    get cx(): CxSmilesWriteParams;
+    set cx(value: CxSmilesWriteParams | CxSmilesWriteParamsOptions);
+}
+
+export class FragmentSmilesWriteParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atoms?: number[], smiles?: SmilesWriteParams | SmilesWriteParamsOptions, bonds?: number[] | null, atom_symbols?: string[] | null, bond_symbols?: string[] | null);
+    atomSymbols: string[] | null;
+    atoms: number[];
+    bondSymbols: string[] | null;
+    bonds: number[] | null;
+    get smiles(): SmilesWriteParams;
+    set smiles(value: SmilesWriteParams | SmilesWriteParamsOptions);
+}
+
+export class FunctionStatus {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly explanation: string | null;
+    readonly kind: string;
+    readonly reference: string | null;
+}
+
+export enum Hybridization {
+    Unspecified = 0,
+    S = 1,
+    Sp = 2,
+    Sp2 = 3,
+    Sp3 = 4,
+    Sp2d = 5,
+    Sp3d = 6,
+    Sp3d2 = 7,
+    Other = 8,
+}
+
 export class HydrogenError {
     private constructor();
     free(): void;
@@ -630,9 +1371,9 @@ 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 LabuteAsaContributions {
@@ -666,14 +1407,16 @@ export class LayeredFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(layers?: number, min_path?: number, max_path?: number, fp_size?: number, atom_counts?: number[] | Uint32Array | null, set_only_bits?: Fingerprint | null, branched_paths?: boolean, from_atoms?: number[] | Uint32Array | null);
-    readonly atomCounts: number[] | null;
-    readonly branchedPaths: boolean;
-    readonly fpSize: number;
-    readonly fromAtoms: number[] | null;
-    readonly layers: number;
-    readonly maxPath: number;
-    readonly minPath: number;
-    readonly setOnlyBits: Fingerprint | null;
+    get atomCounts(): number[] | null;
+    set atomCounts(value: number[] | Uint32Array | null);
+    branchedPaths: boolean;
+    fpSize: number;
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    layers: number;
+    maxPath: number;
+    minPath: number;
+    setOnlyBits: Fingerprint | null;
 }
 
 export class LayeredFingerprintResult {
@@ -689,13 +1432,24 @@ export class LegacyTopologicalTorsionParams {
     [Symbol.dispose](): void;
     constructor(torsion_atom_count?: number, include_chirality?: boolean, fp_size?: number, bits_per_entry?: number, from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null);
     static new(torsion_atom_count?: number, include_chirality?: boolean, fp_size?: number, bits_per_entry?: number, from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null): LegacyTopologicalTorsionParams;
-    readonly bitsPerEntry: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly fpSize: number;
-    readonly fromAtoms: number[] | null;
-    readonly ignoreAtoms: number[] | null;
-    readonly includeChirality: boolean;
-    readonly torsionAtomCount: number;
+    bitsPerEntry: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    fpSize: number;
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
+    includeChirality: boolean;
+    torsionAtomCount: number;
+}
+
+export class LigandRef {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(atom?: number | null);
+    readonly atom: number | null;
+    readonly isImplicitHydrogen: boolean;
 }
 
 export class MaccsFingerprintError {
@@ -715,7 +1469,7 @@ export class MaccsFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(n_bits?: number);
-    readonly nBits: number;
+    nBits: number;
 }
 
 export class MatchError {
@@ -769,20 +1523,13 @@ export class McsAtomCompareParameters {
     free(): void;
     [Symbol.dispose](): void;
     constructor(match_valences?: boolean, match_chiral_tag?: boolean, match_formal_charge?: boolean, ring_matches_ring_only?: boolean, complete_rings_only?: boolean, match_isotope?: boolean, max_distance?: number);
-    get completeRingsOnly(): boolean;
-    set completeRingsOnly(value: any);
-    get matchChiralTag(): boolean;
-    set matchChiralTag(value: any);
-    get matchFormalCharge(): boolean;
-    set matchFormalCharge(value: any);
-    get matchIsotope(): boolean;
-    set matchIsotope(value: any);
-    get matchValences(): boolean;
-    set matchValences(value: any);
-    get maxDistance(): number;
-    set maxDistance(value: any);
-    get ringMatchesRingOnly(): boolean;
-    set ringMatchesRingOnly(value: any);
+    completeRingsOnly: boolean;
+    matchChiralTag: boolean;
+    matchFormalCharge: boolean;
+    matchIsotope: boolean;
+    matchValences: boolean;
+    maxDistance: number;
+    ringMatchesRingOnly: boolean;
 }
 
 export enum McsBondComparator {
@@ -795,16 +1542,11 @@ export class McsBondCompareParameters {
     free(): void;
     [Symbol.dispose](): void;
     constructor(ring_matches_ring_only?: boolean, complete_rings_only?: boolean, match_fused_rings?: boolean, match_fused_rings_strict?: boolean, match_stereo?: boolean);
-    get completeRingsOnly(): boolean;
-    set completeRingsOnly(value: any);
-    get matchFusedRingsStrict(): boolean;
-    set matchFusedRingsStrict(value: any);
-    get matchFusedRings(): boolean;
-    set matchFusedRings(value: any);
-    get matchStereo(): boolean;
-    set matchStereo(value: any);
-    get ringMatchesRingOnly(): boolean;
-    set ringMatchesRingOnly(value: any);
+    completeRingsOnly: boolean;
+    matchFusedRingsStrict: boolean;
+    matchFusedRings: boolean;
+    matchStereo: boolean;
+    ringMatchesRingOnly: boolean;
 }
 
 export class McsError {
@@ -827,16 +1569,11 @@ export class McsParameters {
     get bondCompareParameters(): McsBondCompareParameters;
     set bondCompareParameters(value: McsBondCompareParameters | McsBondCompareParametersOptions);
     initialSeed: string;
-    get maximizeBonds(): boolean;
-    set maximizeBonds(value: any);
-    get storeAll(): boolean;
-    set storeAll(value: any);
-    get threshold(): number;
-    set threshold(value: any);
-    get timeout(): number;
-    set timeout(value: any);
-    get verbose(): boolean;
-    set verbose(value: any);
+    maximizeBonds: boolean;
+    storeAll: boolean;
+    threshold: number;
+    timeout: number;
+    verbose: boolean;
 }
 
 export class McsResult {
@@ -878,10 +1615,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 {
@@ -892,13 +1629,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 {
@@ -955,26 +1692,37 @@ export class Molecule {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    add3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): number;
+    add3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): number;
     addHydrogensWithParams(params: AddHsParams): void;
-    addHydrogens(): void;
+    addHydrogens(params?: AddHsParams | AddHsParamsOptions): void;
     assignAromaticityWithParams(params: AromaticityParams): void;
-    assignAromaticity(): 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(): void;
+    assignRingFamilies(params?: RingSearchParams | RingSearchParamsOptions): void;
     assignRings(): void;
     assignValenceWithParams(params: ValenceParams): void;
-    assignValence(): void;
+    assignValence(params?: ValenceParams | ValenceParamsOptions): void;
+    atomMetadata(recalculate?: boolean): AtomMetadata[];
     atomPropertyString(id: number, key: string): string | null;
     /**
      * Read typed user metadata; a missing key returns null.
      */
     atomProperty(atom: number, key: string): boolean | number | string | number[] | string[] | null;
+    atom(index: number): Atom | null;
     /**
      * Returns atomic numbers in molecule atom order.
      */
     atomicNumbers(): Uint8Array;
+    atoms(): Atom[];
     bondPropertyString(id: number, key: string): string | null;
+    bond(index: number): Bond | null;
+    bonds(): Bond[];
     chi0NWithParams(force: boolean): number;
     chi0N(): number;
     chi0VWithParams(force: boolean): number;
@@ -1001,33 +1749,33 @@ export class Molecule {
     chiNN(order: number): number;
     chiNVWithParams(order: number, force: boolean): number;
     chiNV(order: number): number;
+    cipComputed(): boolean;
+    clear3dConformers(): void;
+    conformers3d(): Conformer3D[];
     /**
      * Returns the first 2D conformer as a flattened `[x0, y0, ...]` array.
      */
     coordinates2d(): Float64Array;
-    /**
-     * Returns a 3D conformer as a flattened `[x0, y0, z0, ...]` array.
-     */
-    coordinates3d(conformer_id: number): Float64Array;
+    coordinates3d(conformer_id?: number): Float64Array;
     crippenDescriptorsWithParams(include_hydrogens: boolean, force: boolean): CrippenTotals;
     crippenDescriptors(): CrippenTotals;
     detectChemistryProblemsWithParams(params: SanitizeParams): ChemistryProblemReport;
-    detectChemistryProblems(): ChemistryProblemReport;
+    detectChemistryProblems(params?: SanitizeParams | SanitizeParamsOptions): ChemistryProblemReport;
     distanceMatrix3dWithParams(params: DistanceMatrix3dParams): DenseMatrix;
-    distanceMatrix3d(): DenseMatrix;
+    distanceMatrix3d(params?: DistanceMatrix3dParams | DistanceMatrix3dParamsOptions): DenseMatrix;
     distanceMatrixWithParams(params: DistanceMatrixParams): DenseMatrix;
-    distanceMatrix(): DenseMatrix;
+    distanceMatrix(params?: DistanceMatrixParams | DistanceMatrixParamsOptions): DenseMatrix;
     exactMolecularWeightWithParams(only_heavy: boolean): number;
     exactMolecularWeight(): number;
     findChiralCenters(include_unassigned?: boolean): Array<[number, string]>;
     fingerprintAtomPairCountWithParams(params: AtomPairFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint32;
-    fingerprintAtomPairCount(): SparseCountFingerprint32;
+    fingerprintAtomPairCount(params?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions): SparseCountFingerprint32;
     fingerprintAtomPairSparseCountWithParams(params: AtomPairFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint;
-    fingerprintAtomPairSparseCount(): SparseCountFingerprint;
+    fingerprintAtomPairSparseCount(params?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions): SparseCountFingerprint;
     fingerprintAtomPairSparseWithParams(params: AtomPairFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseBitFingerprint;
-    fingerprintAtomPairSparse(): SparseBitFingerprint;
+    fingerprintAtomPairSparse(params?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions): SparseBitFingerprint;
     fingerprintAtomPairWithParams(params: AtomPairFingerprintParams, additional_output: FingerprintAdditionalOutput | null): Fingerprint;
-    fingerprintAtomPair(): Fingerprint;
+    fingerprintAtomPair(params?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions): Fingerprint;
     fingerprintAvalonWithParams(params: AvalonFingerprintParams): Fingerprint;
     fingerprintAvalon(params?: AvalonFingerprintParams | AvalonFingerprintOptions): Fingerprint;
     fingerprintLayeredWithOutputWithParams(params: LayeredFingerprintParams): LayeredFingerprintResult;
@@ -1036,67 +1784,70 @@ export class Molecule {
     fingerprintLayered(params?: LayeredFingerprintParams | LayeredFingerprintOptions): Fingerprint;
     fingerprintMaccsRaw(): Fingerprint;
     fingerprintMaccsWithParams(params: MaccsFingerprintParams): Fingerprint;
-    fingerprintMaccs(): Fingerprint;
+    fingerprintMaccs(params?: MaccsFingerprintParams | MaccsFingerprintParamsOptions): Fingerprint;
     fingerprintMorganCountWithGenerator(generator: MorganFingerprintGenerator, params?: MorganCallParams | null, output?: FingerprintAdditionalOutput | null): SparseCountFingerprint32;
     fingerprintMorganCountWithParams(params: MorganFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint32;
-    fingerprintMorganCount(): SparseCountFingerprint32;
+    fingerprintMorganCount(params?: MorganFingerprintParams | MorganFingerprintParamsOptions): SparseCountFingerprint32;
     fingerprintMorganSparseCountWithGenerator(generator: MorganFingerprintGenerator, params?: MorganCallParams | null, output?: FingerprintAdditionalOutput | null): SparseCountFingerprint;
     fingerprintMorganSparseCountWithParams(params: MorganFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint;
-    fingerprintMorganSparseCount(): SparseCountFingerprint;
+    fingerprintMorganSparseCount(params?: MorganFingerprintParams | MorganFingerprintParamsOptions): SparseCountFingerprint;
     fingerprintMorganSparseWithGenerator(generator: MorganFingerprintGenerator, params?: MorganCallParams | null, output?: FingerprintAdditionalOutput | null): SparseBitFingerprint;
     fingerprintMorganSparseWithParams(params: MorganFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseBitFingerprint;
-    fingerprintMorganSparse(): SparseBitFingerprint;
+    fingerprintMorganSparse(params?: MorganFingerprintParams | MorganFingerprintParamsOptions): SparseBitFingerprint;
     fingerprintMorganWithGenerator(generator: MorganFingerprintGenerator, params?: MorganCallParams | null, output?: FingerprintAdditionalOutput | null): Fingerprint;
     fingerprintMorganWithParams(params: MorganFingerprintParams, additional_output: FingerprintAdditionalOutput | null): Fingerprint;
-    fingerprintMorgan(): Fingerprint;
+    fingerprintMorgan(params?: MorganFingerprintParams | MorganFingerprintParamsOptions): Fingerprint;
     fingerprintPatternWithParams(params: PatternFingerprintParams): Fingerprint;
-    fingerprintPattern(): Fingerprint;
+    fingerprintPattern(params?: PatternFingerprintParams | PatternFingerprintParamsOptions): Fingerprint;
     fingerprintTopologicalTorsionCountLegacyWithParams(params: LegacyTopologicalTorsionParams): SparseCountFingerprint;
-    fingerprintTopologicalTorsionCountLegacy(): SparseCountFingerprint;
+    fingerprintTopologicalTorsionCountLegacy(params?: LegacyTopologicalTorsionParams | LegacyTopologicalTorsionParamsOptions): SparseCountFingerprint;
     fingerprintTopologicalTorsionCountWithGenerator(generator: TopologicalTorsionFingerprintGenerator, params?: TopologicalTorsionCallParams | null, output?: FingerprintAdditionalOutput | null): SparseCountFingerprint32;
     fingerprintTopologicalTorsionCountWithParams(params: TopologicalTorsionFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint32;
-    fingerprintTopologicalTorsionCount(): SparseCountFingerprint32;
+    fingerprintTopologicalTorsionCount(params?: TopologicalTorsionFingerprintParams | TopologicalTorsionFingerprintParamsOptions): SparseCountFingerprint32;
     fingerprintTopologicalTorsionLegacyWithParams(params: LegacyTopologicalTorsionParams): Fingerprint;
-    fingerprintTopologicalTorsionLegacy(): Fingerprint;
+    fingerprintTopologicalTorsionLegacy(params?: LegacyTopologicalTorsionParams | LegacyTopologicalTorsionParamsOptions): Fingerprint;
     fingerprintTopologicalTorsionSparseCountLegacyWithParams(params: LegacyTopologicalTorsionParams): SparseCountFingerprint;
-    fingerprintTopologicalTorsionSparseCountLegacy(): SparseCountFingerprint;
+    fingerprintTopologicalTorsionSparseCountLegacy(params?: LegacyTopologicalTorsionParams | LegacyTopologicalTorsionParamsOptions): SparseCountFingerprint;
     fingerprintTopologicalTorsionSparseCountWithGenerator(generator: TopologicalTorsionFingerprintGenerator, params?: TopologicalTorsionCallParams | null, output?: FingerprintAdditionalOutput | null): SparseCountFingerprint;
     fingerprintTopologicalTorsionSparseCountWithParams(params: TopologicalTorsionFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseCountFingerprint;
-    fingerprintTopologicalTorsionSparseCount(): SparseCountFingerprint;
+    fingerprintTopologicalTorsionSparseCount(params?: TopologicalTorsionFingerprintParams | TopologicalTorsionFingerprintParamsOptions): SparseCountFingerprint;
     fingerprintTopologicalTorsionSparseWithGenerator(generator: TopologicalTorsionFingerprintGenerator, params?: TopologicalTorsionCallParams | null, output?: FingerprintAdditionalOutput | null): SparseBitFingerprint;
     fingerprintTopologicalTorsionSparseWithParams(params: TopologicalTorsionFingerprintParams, additional_output: FingerprintAdditionalOutput | null): SparseBitFingerprint;
-    fingerprintTopologicalTorsionSparse(): SparseBitFingerprint;
+    fingerprintTopologicalTorsionSparse(params?: TopologicalTorsionFingerprintParams | TopologicalTorsionFingerprintParamsOptions): SparseBitFingerprint;
     fingerprintTopologicalTorsionWithGenerator(generator: TopologicalTorsionFingerprintGenerator, params?: TopologicalTorsionCallParams | null, output?: FingerprintAdditionalOutput | null): Fingerprint;
     fingerprintTopologicalTorsionWithParams(params: TopologicalTorsionFingerprintParams, additional_output: FingerprintAdditionalOutput | null): Fingerprint;
-    fingerprintTopologicalTorsion(): Fingerprint;
+    fingerprintTopologicalTorsion(params?: TopologicalTorsionFingerprintParams | TopologicalTorsionFingerprintParamsOptions): Fingerprint;
     fingerprintTopologicalWithOutputWithParams(params: TopologicalFingerprintParams, request: TopologicalFingerprintOutputRequest): TopologicalFingerprintResult;
-    fingerprintTopologicalWithOutput(): TopologicalFingerprintResult;
+    fingerprintTopologicalWithOutput(params?: TopologicalFingerprintParams | TopologicalFingerprintParamsOptions, request?: TopologicalFingerprintOutputRequest | TopologicalFingerprintOutputRequestOptions): TopologicalFingerprintResult;
     fingerprintTopologicalWithParams(params: TopologicalFingerprintParams): Fingerprint;
-    fingerprintTopological(): Fingerprint;
+    fingerprintTopological(params?: TopologicalFingerprintParams | TopologicalFingerprintParamsOptions): Fingerprint;
     fractionCsp3(): number;
     /**
      * 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;
     hallKierAlphaWithContributions(): [number, Float64Array];
     hallKierAlpha(): number;
+    has2dCoordinates(): boolean;
     hasSubstructMatchWithParams(query: QueryGraph, params: SubstructMatchParams): boolean;
     hasSubstructMatch(query: QueryGraph, params?: SubstructMatchParams | SubstructMatchOptions): boolean;
+    hasValenceViolation(atom_id: number): boolean;
     kappa1(): number;
     kappa2(): number;
     kappa3(): number;
     kekulizeBondsWithParams(params: KekulizeParams): void;
-    kekulizeBonds(): void;
+    kekulizeBonds(params?: KekulizeParams | KekulizeParamsOptions): void;
     labuteAsaContributionsWithParams(include_hydrogens: boolean, force: boolean): LabuteAsaContributions;
     labuteAsaContributions(): LabuteAsaContributions;
     labuteAsaWithParams(include_hydrogens: boolean, force: boolean): number;
@@ -1168,7 +1919,11 @@ export class Molecule {
     numSaturatedRings(): number;
     numSpiroAtoms(): number;
     numUnspecifiedAtomStereoCenters(): number;
+    perceiveStereochemistry(): void;
     phi(): number;
+    potentialStereoWithParams(params: PotentialStereoParams): PotentialStereoResult;
+    potentialStereo(params?: PotentialStereoParams | PotentialStereoParamsOptions): PotentialStereoResult;
+    properties(): MoleculeProperties;
     /**
      * Returns user/computed property names in stable source insertion order.
      */
@@ -1178,20 +1933,21 @@ export class Molecule {
      * Wrong value kinds and invalid UTF-8 propagate as binding errors.
      */
     propertyOrEmpty(key: string): string;
+    property(key: string): PropertyValue | null;
     qed(): number;
     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;
+    removeHydrogens(params?: RemoveHsParams | RemoveHsParamsOptions): void;
     sanitizeWithParams(params: SanitizeParams): Molecule;
     sanitizeWithParams_(params: SanitizeParams): void;
-    sanitize(): Molecule;
-    sanitize_(): void;
+    sanitize(params?: SanitizeParams | SanitizeParamsOptions): Molecule;
+    sanitize_(params?: SanitizeParams | SanitizeParamsOptions): void;
     /**
      * Returns SDF data-field names in their source order, including duplicates.
      */
@@ -1200,10 +1956,18 @@ 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;
+    setOnly3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): number;
+    setOnly3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): number;
     slogpVsa10(): number;
     slogpVsa11(): number;
     slogpVsa12(): number;
@@ -1235,44 +1999,75 @@ export class Molecule {
     substructMatchesCompiled(query: CompiledQuery): MatchResult[];
     substructMatchesWithParams(query: QueryGraph, params: SubstructMatchParams): MatchResult[];
     substructMatches(query: QueryGraph, params?: SubstructMatchParams | SubstructMatchOptions): MatchResult[];
+    tetrahedralStereo(): TetrahedralStereo[];
+    toBuilder(): MoleculeBuilder;
+    toCxSmartsWithParams(params: SmartsWriteParams): string;
+    toCxSmarts(params?: SmartsWriteParams | SmartsWriteParamsOptions): string;
+    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;
+    toSmartsWithParams(params: SmartsWriteParams): string;
+    toSmarts(params?: SmartsWriteParams | SmartsWriteParamsOptions): string;
+    toSmilesWithParams(params: SmilesWriteParams): string;
+    toSmiles(params?: SmilesWriteParams | SmilesWriteParamsOptions): string;
     toXyzWithParams(params: XyzWriteParams): string;
-    toXyz(): string;
+    toXyz(params?: XyzWriteParams | XyzWriteParamsOptions): string;
     topologicalTorsionIdsWithParams(torsion_atom_count: number): bigint[];
     topologicalTorsionIds(): bigint[];
     topologicalTorsionPathScore(path: number[] | Uint32Array, size: number, atom_codes?: number[] | Uint32Array | null): bigint;
+    topology(): TopologyBlock;
     totalAtomCount(): number;
     tpsaWithParams(include_sulfur_phosphorus: boolean, force: boolean): number;
     tpsa(): number;
+    with2dCoordinateBlockWithParams(coordinates: number[][], params: Coordinate2DInputParams): Molecule;
+    with2dCoordinateBlock(coordinates: number[][], params?: Coordinate2DInputParams | Coordinate2DInputParamsOptions): Molecule;
+    with3dCoordinatesWithParams(coordinates: number[][], params: Replace3DCoordinatesParams): Molecule;
+    with3dCoordinates(coordinates: number[][], params?: Replace3DCoordinatesParams | Replace3DCoordinatesParamsOptions): Molecule;
+    withAdded3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): Molecule;
+    withAdded3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): Molecule;
     withAssignedAromaticityWithParams(params: AromaticityParams): Molecule;
-    withAssignedAromaticity(): Molecule;
+    withAssignedAromaticity(params?: AromaticityParams | AromaticityParamsOptions): Molecule;
     withAssignedRadicals(): Molecule;
     withAssignedRingFamiliesWithParams(params: RingSearchParams): Molecule;
-    withAssignedRingFamilies(): Molecule;
+    withAssignedRingFamilies(params?: RingSearchParams | RingSearchParamsOptions): Molecule;
     withAssignedRings(): Molecule;
     withAssignedValenceWithParams(params: ValenceParams): Molecule;
-    withAssignedValence(): Molecule;
+    withAssignedValence(params?: ValenceParams | ValenceParamsOptions): Molecule;
     withAtomPairAtomCode(atom_id: number, branch_subtract?: number, include_chirality?: boolean, use_legacy_stereo_perception?: boolean): AtomPairAtomCodeResult;
+    withAtomPositionWithParams(atom: number, position: [number, number, number], params: AtomPositionParams): Molecule;
+    withAtomPosition(atom: number, position: [number, number, number], params?: AtomPositionParams | AtomPositionParamsOptions): Molecule;
     /**
      * Return a new molecule; the receiver and its shared copies are unchanged.
      */
     withAtomProperty(atom: number, key: string, value: boolean | number | string | number[] | string[]): Molecule;
+    withChiralTagsFromStructureWithParams(params: StructureTagParams): Molecule;
+    withChiralTagsFromStructure(params?: StructureTagParams | StructureTagParamsOptions): Molecule;
+    withCipLabelsWithOptions(options: CipLabelOptions): Molecule;
+    withCipLabels(options?: CipLabelOptions | CipLabelOptionsOptions): Molecule;
+    withCleared3dConformers(): Molecule;
     withHydrogensWithParams(params: AddHsParams): Molecule;
-    withHydrogens(): Molecule;
+    withHydrogens(params?: AddHsParams | AddHsParamsOptions): Molecule;
     withKekulizedBondsWithParams(params: KekulizeParams): Molecule;
-    withKekulizedBonds(): Molecule;
+    withKekulizedBonds(params?: KekulizeParams | KekulizeParamsOptions): Molecule;
     /**
      * Returns a molecule with its name replaced.
      */
     withName(name: string): Molecule;
+    withOnly3dConformerWithParams(coordinates: number[][], params: Coordinate3DInputParams): Molecule;
+    withOnly3dConformer(coordinates: number[][], params?: Coordinate3DInputParams | Coordinate3DInputParamsOptions): Molecule;
     /**
      * Returns a molecule with a string property replaced or inserted.
      */
@@ -1282,15 +2077,15 @@ export class Molecule {
      */
     withSdfDataField(key: string, value: string): Molecule;
     withoutHydrogensWithParams(params: RemoveHsParams): Molecule;
-    withoutHydrogens(): Molecule;
+    withoutHydrogens(params?: RemoveHsParams | RemoveHsParamsOptions): Molecule;
     writeMolWithParams(path: string, params: MolBlockWriteParams): void;
-    writeMol(path: string): void;
+    writeMol(path: string, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): void;
     writeSdfFilesWithParams(directory: string, file_name: string | null, params: MolBlockWriteParams): string;
-    writeSdfFiles(directory: string, file_name: string | null): string;
+    writeSdfFiles(directory: string, file_name: string | null, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): string;
     writeSdfWithParams(path: string, params: MolBlockWriteParams): void;
-    writeSdf(path: string): void;
+    writeSdf(path: string, params?: MolBlockWriteParams | MolBlockWriteParamsOptions): void;
     writeXyzWithParams(path: string, params: XyzWriteParams): void;
-    writeXyz(path: string): void;
+    writeXyz(path: string, params?: XyzWriteParams | XyzWriteParamsOptions): void;
 }
 
 export class MoleculeBatch {
@@ -1300,33 +2095,35 @@ export class MoleculeBatch {
     errorMode(): BatchErrorMode;
     errors(): BatchError[];
     fingerprintAtomPairCountListWithParams(options: AtomPairFingerprintParams, params: BatchQueryParams): (SparseCountFingerprint32 | null)[];
-    fingerprintAtomPairCountList(): (SparseCountFingerprint32 | null)[];
+    fingerprintAtomPairCountList(options?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (SparseCountFingerprint32 | null)[];
     fingerprintAtomPairListWithParams(options: AtomPairFingerprintParams, params: BatchQueryParams): (Fingerprint | null)[];
-    fingerprintAtomPairList(): (Fingerprint | null)[];
+    fingerprintAtomPairList(options?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (Fingerprint | null)[];
     fingerprintAtomPairSparseBitsListWithParams(options: AtomPairFingerprintParams, params: BatchQueryParams): (SparseBitFingerprint | null)[];
-    fingerprintAtomPairSparseBitsList(): (SparseBitFingerprint | null)[];
+    fingerprintAtomPairSparseBitsList(options?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (SparseBitFingerprint | null)[];
     fingerprintAtomPairSparseCountListWithParams(options: AtomPairFingerprintParams, params: BatchQueryParams): (SparseCountFingerprint | null)[];
-    fingerprintAtomPairSparseCountList(): (SparseCountFingerprint | null)[];
+    fingerprintAtomPairSparseCountList(options?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (SparseCountFingerprint | null)[];
     fingerprintAtomPairWithOutputListWithParams(options: AtomPairFingerprintParams, collect_additional_output: boolean, params: BatchQueryParams): (BatchFingerprintOutput | null)[];
-    fingerprintAtomPairWithOutputList(): (BatchFingerprintOutput | null)[];
+    fingerprintAtomPairWithOutputList(options?: AtomPairFingerprintParams | AtomPairFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (BatchFingerprintOutput | null)[];
     fingerprintLayeredListWithParams(options: LayeredFingerprintParams, params: BatchQueryParams): (Fingerprint | null)[];
-    fingerprintLayeredList(): (Fingerprint | null)[];
+    fingerprintLayeredList(options?: LayeredFingerprintParams | LayeredFingerprintOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (Fingerprint | null)[];
     fingerprintLayeredWithOutputListWithParams(options: LayeredFingerprintParams, params: BatchQueryParams): (LayeredFingerprintResult | null)[];
-    fingerprintLayeredWithOutputList(): (LayeredFingerprintResult | null)[];
+    fingerprintLayeredWithOutputList(options?: LayeredFingerprintParams | LayeredFingerprintOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (LayeredFingerprintResult | null)[];
     fingerprintMorganListWithGeneratorParams(options: MorganParams, atom_invariants: MorganAtomInvariantsGenerator | null, bond_invariants: MorganBondInvariantsGenerator | null, call: MorganCallParams, params: BatchQueryParams): (Fingerprint | null)[];
     fingerprintMorganListWithParams(options: MorganFingerprintParams, params: BatchQueryParams): (Fingerprint | null)[];
-    fingerprintMorganList(): (Fingerprint | null)[];
+    fingerprintMorganList(options?: MorganFingerprintParams | MorganFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (Fingerprint | null)[];
     fingerprintMorganWithOutputListWithGeneratorParams(options: MorganParams, atom_invariants: MorganAtomInvariantsGenerator | null, bond_invariants: MorganBondInvariantsGenerator | null, call: MorganCallParams, collect_additional_output: boolean, params: BatchQueryParams): (BatchFingerprintOutput | null)[];
     fingerprintMorganWithOutputListWithParams(options: MorganFingerprintParams, collect_additional_output: boolean, params: BatchQueryParams): (BatchFingerprintOutput | null)[];
-    fingerprintMorganWithOutputList(): (BatchFingerprintOutput | null)[];
+    fingerprintMorganWithOutputList(options?: MorganFingerprintParams | MorganFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (BatchFingerprintOutput | null)[];
     fingerprintPatternListWithParams(options: PatternFingerprintParams, params: BatchQueryParams): (Fingerprint | null)[];
-    fingerprintPatternList(): (Fingerprint | null)[];
+    fingerprintPatternList(options?: PatternFingerprintParams | PatternFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (Fingerprint | null)[];
+    fingerprintTopologicalTorsionListWithParams(options: TopologicalTorsionFingerprintParams, params: BatchQueryParams): (Fingerprint | null)[];
+    fingerprintTopologicalTorsionList(options?: TopologicalTorsionFingerprintParams | TopologicalTorsionFingerprintParamsOptions, params?: BatchQueryParams | BatchQueryParamsOptions): (Fingerprint | null)[];
     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[];
@@ -1335,28 +2132,59 @@ 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 MoleculeHashError {
@@ -1371,6 +2199,28 @@ export class MoleculeHashError {
     readonly message: string;
 }
 
+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 {
     private constructor();
     free(): void;
@@ -1397,9 +2247,9 @@ export class MorganBondInvariantsGenerator {
     free(): void;
     [Symbol.dispose](): void;
     constructor(use_bond_types?: boolean, include_chirality?: boolean);
-    includeChirality(): boolean;
     static new(use_bond_types?: boolean, include_chirality?: boolean): MorganBondInvariantsGenerator;
-    useBondTypes(): boolean;
+    includeChirality: boolean;
+    useBondTypes: boolean;
 }
 
 export class MorganCallParams {
@@ -1407,11 +2257,15 @@ export class MorganCallParams {
     [Symbol.dispose](): void;
     constructor(from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number);
     static new(from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number): MorganCallParams;
-    readonly conformerId: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly customBondInvariants: number[] | null;
-    readonly fromAtoms: number[] | null;
-    readonly ignoreAtoms: number[] | null;
+    conformerId: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    get customBondInvariants(): number[] | null;
+    set customBondInvariants(value: number[] | Uint32Array | null);
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
 }
 
 export class MorganFingerprintGenerator {
@@ -1433,13 +2287,19 @@ export class MorganFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(generator?: MorganParams | null, from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number, invariants?: MorganInvariants | null);
-    readonly conformerId: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly customBondInvariants: number[] | null;
-    readonly fromAtoms: number[] | null;
-    readonly generator: MorganParams;
-    readonly ignoreAtoms: number[] | null;
-    readonly invariants: MorganInvariants;
+    conformerId: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    get customBondInvariants(): number[] | null;
+    set customBondInvariants(value: number[] | Uint32Array | null);
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get generator(): MorganParams;
+    set generator(value: MorganParams | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
+    get invariants(): MorganInvariants;
+    set invariants(value: MorganInvariants | null);
 }
 
 export class MorganInvariants {
@@ -1457,16 +2317,17 @@ export class MorganParams {
     constructor(radius?: number, include_chirality?: boolean, use_bond_types?: boolean, include_ring_membership?: boolean, only_nonzero_invariants?: boolean, include_redundant_environments?: boolean, fp_size?: number, count_simulation?: boolean, count_bounds?: number[] | Uint32Array | null, bits_per_feature?: number);
     toJson(): string;
     withJson(json: string): MorganParams;
-    readonly bitsPerFeature: number;
-    readonly countBounds: number[];
-    readonly countSimulation: boolean;
-    readonly fpSize: number;
-    readonly includeChirality: boolean;
-    readonly includeRedundantEnvironments: boolean;
-    readonly includeRingMembership: boolean;
-    readonly onlyNonzeroInvariants: boolean;
-    readonly radius: number;
-    readonly useBondTypes: boolean;
+    bitsPerFeature: number;
+    get countBounds(): number[];
+    set countBounds(value: number[] | Uint32Array | null);
+    countSimulation: boolean;
+    fpSize: number;
+    includeChirality: boolean;
+    includeRedundantEnvironments: boolean;
+    includeRingMembership: boolean;
+    onlyNonzeroInvariants: boolean;
+    radius: number;
+    useBondTypes: boolean;
 }
 
 export class MorganReadError {
@@ -1503,6 +2364,40 @@ export class MorganSettings {
     radius: number;
 }
 
+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 PatternFingerprintError {
     private constructor();
     free(): void;
@@ -1517,8 +2412,83 @@ export class PatternFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(n_bits?: number, tautomeric?: boolean);
-    readonly nBits: number;
-    readonly tautomeric: boolean;
+    nBits: number;
+    tautomeric: boolean;
+}
+
+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 {
@@ -1600,41 +2570,67 @@ export class QueryGraph {
     free(): void;
     [Symbol.dispose](): void;
     static fromSmartsWithParams(text: string, params: SmartsParseParams): QueryGraph;
-    static fromSmarts(text: string): QueryGraph;
+    static fromSmarts(text: string, params?: SmartsParseParams | SmartsParseParamsOptions): QueryGraph;
     name(): string | null;
     numAtoms(): number;
     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 enum RotatableBondsOptions {
@@ -1711,7 +2707,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 {
@@ -1754,11 +2751,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 {
@@ -1808,16 +2805,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 {
@@ -1826,7 +2837,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;
 }
@@ -1847,7 +2858,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;
@@ -1857,9 +2868,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 {
@@ -1884,7 +2895,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;
 }
 
@@ -1912,13 +2923,14 @@ export class SmartsParseParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(allow_cxsmiles?: boolean, strict_cxsmiles?: boolean, parse_name?: boolean, merge_hs?: boolean, skip_cleanup?: boolean, debug_parse?: boolean, replacements?: Map<string, string> | Record<string, string> | null);
-    readonly allowCxsmiles: boolean;
-    readonly debugParse: boolean;
-    readonly mergeHs: boolean;
-    readonly parseName: boolean;
-    readonly replacements: Map<string, string>;
-    readonly skipCleanup: boolean;
-    readonly strictCxsmiles: boolean;
+    allowCxsmiles: boolean;
+    debugParse: boolean;
+    mergeHs: boolean;
+    parseName: boolean;
+    get replacements(): Map<string, string>;
+    set replacements(value: Map<string, string> | Record<string, string> | null);
+    skipCleanup: boolean;
+    strictCxsmiles: boolean;
 }
 
 export class SmartsWriteError {
@@ -1935,10 +2947,10 @@ export class SmartsWriteParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(include_atom_maps?: boolean, isomeric_smiles?: boolean, include_dative_bonds?: boolean, rooted_at_atom?: number | null);
-    readonly includeAtomMaps: boolean;
-    readonly includeDativeBonds: boolean;
-    readonly isomericSmiles: boolean;
-    readonly rootedAtAtom: number | null;
+    includeAtomMaps: boolean;
+    includeDativeBonds: boolean;
+    isomericSmiles: boolean;
+    rootedAtAtom: number | null;
 }
 
 export class SmilesError {
@@ -1955,14 +2967,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 {
@@ -1979,15 +3007,15 @@ 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 SparseBitFingerprint {
@@ -2038,6 +3066,31 @@ export class SparseCountFingerprint32 {
     withSubtracted(other: SparseCountFingerprint32): SparseCountFingerprint32;
 }
 
+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 {
     private constructor();
     free(): void;
@@ -2048,6 +3101,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;
@@ -2107,23 +3168,74 @@ export class SubstructMatchError {
 export class SubstructMatchParams {
     free(): void;
     [Symbol.dispose](): void;
-    constructor(max_matches?: number, uniquify?: boolean, use_chirality?: boolean, use_enhanced_stereo?: boolean, specified_stereo_query_matches_unspecified?: boolean, use_query_query_matches?: boolean, recursion_possible?: boolean, max_recursive_matches?: number, num_threads?: number, aromatic_matches_conjugated?: boolean, aromatic_matches_single_or_double?: boolean, atom_properties?: string[] | null, bond_properties?: string[] | null, extra_atom_check_overrides_default_check?: boolean, extra_bond_check_overrides_default_check?: boolean, use_generic_matchers?: boolean);
-    readonly aromaticMatchesConjugated: boolean;
-    readonly aromaticMatchesSingleOrDouble: boolean;
-    readonly atomProperties: string[];
-    readonly bondProperties: string[];
-    readonly extraAtomCheckOverridesDefaultCheck: boolean;
-    readonly extraBondCheckOverridesDefaultCheck: boolean;
-    readonly maxMatches: number;
-    readonly maxRecursiveMatches: number;
-    readonly numThreads: number;
-    readonly recursionPossible: boolean;
-    readonly specifiedStereoQueryMatchesUnspecified: boolean;
-    readonly uniquify: boolean;
-    readonly useChirality: boolean;
-    readonly useEnhancedStereo: boolean;
-    readonly useGenericMatchers: boolean;
-    readonly useQueryQueryMatches: boolean;
+    constructor(max_matches?: number, uniquify?: boolean, use_chirality?: boolean, use_enhanced_stereo?: boolean, specified_stereo_query_matches_unspecified?: boolean, use_query_query_matches?: boolean, recursion_possible?: boolean, max_recursive_matches?: number, num_threads?: number, aromatic_matches_conjugated?: boolean, aromatic_matches_single_or_double?: boolean, atom_properties?: string[] | null, bond_properties?: string[] | null, extra_atom_check_overrides_default_check?: boolean, extra_bond_check_overrides_default_check?: boolean, use_generic_matchers?: boolean, final_match?: ((target: Molecule, atoms: number[]) => boolean) | null, atom_match?: ((query: QueryAtom, target: Atom) => boolean) | null, bond_match?: ((query: Bond, target: Bond) => boolean) | null);
+    aromaticMatchesConjugated: boolean;
+    aromaticMatchesSingleOrDouble: boolean;
+    atomMatch: ((query: QueryAtom, target: Atom) => boolean) | null;
+    get atomProperties(): string[];
+    set atomProperties(value: string[] | null);
+    bondMatch: ((query: Bond, target: Bond) => boolean) | null;
+    get bondProperties(): string[];
+    set bondProperties(value: string[] | null);
+    extraAtomCheckOverridesDefaultCheck: boolean;
+    extraBondCheckOverridesDefaultCheck: boolean;
+    finalMatch: ((target: Molecule, atoms: number[]) => boolean) | null;
+    maxMatches: number;
+    maxRecursiveMatches: number;
+    numThreads: number;
+    recursionPossible: boolean;
+    specifiedStereoQueryMatchesUnspecified: boolean;
+    uniquify: boolean;
+    useChirality: boolean;
+    useEnhancedStereo: boolean;
+    useGenericMatchers: boolean;
+    useQueryQueryMatches: boolean;
+}
+
+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 TopologicalFingerprintError {
@@ -2150,25 +3262,27 @@ export class TopologicalFingerprintOutputRequest {
     free(): void;
     [Symbol.dispose](): void;
     constructor(atom_bits?: boolean, bit_info?: boolean);
-    readonly atomBits: boolean;
-    readonly bitInfo: boolean;
+    atomBits: boolean;
+    bitInfo: boolean;
 }
 
 export class TopologicalFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(min_path?: number, max_path?: number, fp_size?: number, num_bits_per_feature?: number, use_hs?: boolean, target_density?: number, min_size?: number, branched_paths?: boolean, use_bond_order?: boolean, atom_invariants?: number[] | Uint32Array | null, from_atoms?: number[] | Uint32Array | null);
-    readonly atomInvariants: number[] | null;
-    readonly branchedPaths: boolean;
-    readonly fpSize: number;
-    readonly fromAtoms: number[] | null;
-    readonly maxPath: number;
-    readonly minPath: number;
-    readonly minSize: number;
-    readonly numBitsPerFeature: number;
-    readonly targetDensity: number;
-    readonly useBondOrder: boolean;
-    readonly useHs: boolean;
+    get atomInvariants(): number[] | null;
+    set atomInvariants(value: number[] | Uint32Array | null);
+    branchedPaths: boolean;
+    fpSize: number;
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    maxPath: number;
+    minPath: number;
+    minSize: number;
+    numBitsPerFeature: number;
+    targetDensity: number;
+    useBondOrder: boolean;
+    useHs: boolean;
 }
 
 export class TopologicalFingerprintResult {
@@ -2184,12 +3298,16 @@ export class TopologicalTorsionCallParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number, use_legacy_stereo_perception?: boolean);
-    readonly conformerId: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly customBondInvariants: number[] | null;
-    readonly fromAtoms: number[] | null;
-    readonly ignoreAtoms: number[] | null;
-    readonly useLegacyStereoPerception: boolean;
+    conformerId: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    get customBondInvariants(): number[] | null;
+    set customBondInvariants(value: number[] | Uint32Array | null);
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
+    useLegacyStereoPerception: boolean;
 }
 
 export class TopologicalTorsionFingerprintGenerator {
@@ -2211,14 +3329,19 @@ export class TopologicalTorsionFingerprintParams {
     free(): void;
     [Symbol.dispose](): void;
     constructor(generator?: TopologicalTorsionParams | null, from_atoms?: number[] | Uint32Array | null, ignore_atoms?: number[] | Uint32Array | null, custom_atom_invariants?: number[] | Uint32Array | null, custom_bond_invariants?: number[] | Uint32Array | null, conformer_id?: number, atom_invariants_generator?: AtomPairAtomInvariantsGenerator | null, use_legacy_stereo_perception?: boolean);
-    readonly atomInvariantsGenerator: AtomPairAtomInvariantsGenerator | null;
-    readonly conformerId: number;
-    readonly customAtomInvariants: number[] | null;
-    readonly customBondInvariants: number[] | null;
-    readonly fromAtoms: number[] | null;
-    readonly generator: TopologicalTorsionParams;
-    readonly ignoreAtoms: number[] | null;
-    readonly useLegacyStereoPerception: boolean;
+    atomInvariantsGenerator: AtomPairAtomInvariantsGenerator | null;
+    conformerId: number;
+    get customAtomInvariants(): number[] | null;
+    set customAtomInvariants(value: number[] | Uint32Array | null);
+    get customBondInvariants(): number[] | null;
+    set customBondInvariants(value: number[] | Uint32Array | null);
+    get fromAtoms(): number[] | null;
+    set fromAtoms(value: number[] | Uint32Array | null);
+    get generator(): TopologicalTorsionParams;
+    set generator(value: TopologicalTorsionParams | null);
+    get ignoreAtoms(): number[] | null;
+    set ignoreAtoms(value: number[] | Uint32Array | null);
+    useLegacyStereoPerception: boolean;
 }
 
 export class TopologicalTorsionParams {
@@ -2228,13 +3351,14 @@ export class TopologicalTorsionParams {
     infoString(): string;
     toJson(): string;
     withJson(json: string): TopologicalTorsionParams;
-    readonly bitsPerFeature: number;
-    readonly countBounds: number[];
-    readonly countSimulation: boolean;
-    readonly fpSize: number;
-    readonly includeChirality: boolean;
-    readonly onlyShortestPaths: boolean;
-    readonly torsionAtomCount: number;
+    bitsPerFeature: number;
+    get countBounds(): number[];
+    set countBounds(value: number[] | Uint32Array | null);
+    countSimulation: boolean;
+    fpSize: number;
+    includeChirality: boolean;
+    onlyShortestPaths: boolean;
+    torsionAtomCount: number;
 }
 
 export class TopologicalTorsionPathScoreError {
@@ -2285,6 +3409,26 @@ export class TopologicalTorsionSettings {
     torsionAtomCount: number;
 }
 
+export class TopologyBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly atoms: Atom[];
+    readonly bonds: Bond[];
+    readonly stereoGroups: StereoGroup[];
+    readonly substanceGroups: SubstanceGroup[];
+}
+
+export class TransformError {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cause: Error | null;
+    readonly domain: string;
+    readonly kind: string;
+    readonly message: string;
+}
+
 export class ValenceError {
     private constructor();
     free(): void;
@@ -2323,8 +3467,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 {
@@ -2354,8 +3498,8 @@ 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 compileQuery(query: QueryGraph): CompiledQuery;
@@ -2364,11 +3508,15 @@ export function elementInfo(element: Element): ElementInfo;
 
 export function explainPathScore(score: bigint, size?: number): [string, number, number][];
 
+export function featureSpec(name: string): FeatureSpec | null;
+
+export function featureSpecs(): FeatureSpecIter;
+
 export function fingerprintLayeredQueryWithOutputWithParams(query: QueryGraph, params: LayeredFingerprintParams): LayeredFingerprintResult;
 
 export function fingerprintLayeredQueryWithParams(query: QueryGraph, params: LayeredFingerprintParams): Fingerprint;
 
-export function fingerprintPatternQuery(query: QueryGraph): Fingerprint;
+export function fingerprintPatternQuery(query: QueryGraph, params?: PatternFingerprintParams | PatternFingerprintParamsOptions): Fingerprint;
 
 export function fingerprintPatternQueryWithParams(query: QueryGraph, params: PatternFingerprintParams): Fingerprint;
 
@@ -2380,10 +3528,26 @@ export function maximumCommonSubstructure(molecules: Molecule[], params?: McsPar
 
 export function maximumCommonSubstructureWithParams(molecules: Molecule[], params: McsParameters): McsResult;
 
-export function parseSmarts(text: string): QueryGraph;
+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 parseSmarts(text: string, params?: SmartsParseParams | SmartsParseParamsOptions): QueryGraph;
 
 export function parseSmartsWithParams(text: string, params: SmartsParseParams): QueryGraph;
 
+export function propertyValueToText(value: PropertyValue): string;
+
+export function supportMatrix(): SupportMatrixEntry[];
+
 /**
  * Returns the COSMolKit version through the binding-facing crate.
  */
@@ -2400,14 +3564,18 @@ export interface InitOutput {
     readonly __wbg_addhsparams_free: (a: number, b: number) => void;
     readonly __wbg_aromaticityerror_free: (a: number, b: number) => void;
     readonly __wbg_aromaticityparams_free: (a: number, b: number) => void;
+    readonly __wbg_atom_free: (a: number, b: number) => void;
     readonly __wbg_atomcodeexplanation_free: (a: number, b: number) => void;
     readonly __wbg_atomcodeexplanationerror_free: (a: number, b: number) => void;
+    readonly __wbg_atommetadata_free: (a: number, b: number) => void;
     readonly __wbg_atompairatomcoderesult_free: (a: number, b: number) => void;
     readonly __wbg_atompairatominvariantsgenerator_free: (a: number, b: number) => void;
     readonly __wbg_atompairfingerprintparams_free: (a: number, b: number) => void;
     readonly __wbg_atompairparams_free: (a: number, b: number) => void;
     readonly __wbg_atompairreaderror_free: (a: number, b: number) => void;
     readonly __wbg_atompairsparameters_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_avalonengineerror_free: (a: number, b: number) => void;
     readonly __wbg_avalonfingerprinterror_free: (a: number, b: number) => void;
     readonly __wbg_avalonfingerprintflags_free: (a: number, b: number) => void;
@@ -2422,12 +3590,28 @@ export interface InitOutput {
     readonly __wbg_batchqueryparams_free: (a: number, b: number) => void;
     readonly __wbg_batchrecord_free: (a: number, b: number) => void;
     readonly __wbg_batchvalidationerror_free: (a: number, b: number) => void;
+    readonly __wbg_bond_free: (a: number, b: number) => void;
+    readonly __wbg_bondspec_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblem_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblemerror_free: (a: number, b: number) => void;
     readonly __wbg_chemistryproblemreport_free: (a: number, b: number) => void;
+    readonly __wbg_cipdescriptorerror_free: (a: number, b: number) => void;
+    readonly __wbg_ciplabelererror_free: (a: number, b: number) => void;
+    readonly __wbg_ciplabeloptions_free: (a: number, b: number) => void;
     readonly __wbg_ciprankerror_free: (a: number, b: number) => void;
     readonly __wbg_compiledquery_free: (a: number, b: number) => void;
+    readonly __wbg_conformer2d_free: (a: number, b: number) => void;
+    readonly __wbg_conformer3d_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate2dinputparams_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate3dinputparams_free: (a: number, b: number) => void;
+    readonly __wbg_coordinate3dreaderror_free: (a: number, b: number) => void;
+    readonly __wbg_coordinateblock_free: (a: number, b: number) => void;
+    readonly __wbg_coordinateinputerror_free: (a: number, b: number) => void;
+    readonly __wbg_coordinatezpolicy_free: (a: number, b: number) => void;
     readonly __wbg_crippentotals_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_descriptorerror_free: (a: number, b: number) => void;
     readonly __wbg_descriptorreaderror_free: (a: number, b: number) => void;
@@ -2435,11 +3619,16 @@ export interface InitOutput {
     readonly __wbg_distancematrixparams_free: (a: number, b: number) => void;
     readonly __wbg_element_free: (a: number, b: number) => void;
     readonly __wbg_elementinfo_free: (a: number, b: number) => void;
+    readonly __wbg_featurespec_free: (a: number, b: number) => void;
+    readonly __wbg_featurespeciter_free: (a: number, b: number) => void;
     readonly __wbg_fingerprint_free: (a: number, b: number) => void;
     readonly __wbg_fingerprintadditionaloutput_free: (a: number, b: number) => void;
     readonly __wbg_fingerprinterror_free: (a: number, b: number) => void;
     readonly __wbg_fingerprintjsonerror_free: (a: number, b: number) => void;
     readonly __wbg_fingerprintpreparationerror_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;
@@ -2449,6 +3638,7 @@ export interface InitOutput {
     readonly __wbg_layeredfingerprintparams_free: (a: number, b: number) => void;
     readonly __wbg_layeredfingerprintresult_free: (a: number, b: number) => void;
     readonly __wbg_legacytopologicaltorsionparams_free: (a: number, b: number) => void;
+    readonly __wbg_ligandref_free: (a: number, b: number) => void;
     readonly __wbg_maccsfingerprinterror_free: (a: number, b: number) => void;
     readonly __wbg_maccsfingerprintparams_free: (a: number, b: number) => void;
     readonly __wbg_matcherror_free: (a: number, b: number) => void;
@@ -2467,7 +3657,9 @@ export interface InitOutput {
     readonly __wbg_molecularioerror_free: (a: number, b: number) => void;
     readonly __wbg_molecule_free: (a: number, b: number) => void;
     readonly __wbg_moleculebatch_free: (a: number, b: number) => void;
+    readonly __wbg_moleculebuilder_free: (a: number, b: number) => void;
     readonly __wbg_moleculehasherror_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_morganatominvariantsgenerator_free: (a: number, b: number) => void;
@@ -2479,16 +3671,27 @@ export interface InitOutput {
     readonly __wbg_morganparams_free: (a: number, b: number) => void;
     readonly __wbg_morganreaderror_free: (a: number, b: number) => void;
     readonly __wbg_morgansettings_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_patternfingerprinterror_free: (a: number, b: number) => void;
     readonly __wbg_patternfingerprintparams_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_queryatom_free: (a: number, b: number) => void;
     readonly __wbg_querycompileerror_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;
@@ -2500,6 +3703,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;
@@ -2513,17 +3717,26 @@ export interface InitOutput {
     readonly __wbg_smartswriteparams_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_sparsebitfingerprint_free: (a: number, b: number) => void;
     readonly __wbg_sparsecountfingerprint32_free: (a: number, b: number) => void;
     readonly __wbg_sparsecountfingerprint_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_substructmatcherror_free: (a: number, b: number) => void;
     readonly __wbg_substructmatchparams_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_topologicalfingerprinterror_free: (a: number, b: number) => void;
     readonly __wbg_topologicalfingerprintoutput_free: (a: number, b: number) => void;
     readonly __wbg_topologicalfingerprintoutputrequest_free: (a: number, b: number) => void;
@@ -2536,6 +3749,8 @@ export interface InitOutput {
     readonly __wbg_topologicaltorsionpathscoreerror_free: (a: number, b: number) => void;
     readonly __wbg_topologicaltorsionreaderror_free: (a: number, b: number) => void;
     readonly __wbg_topologicaltorsionsettings_free: (a: number, b: number) => void;
+    readonly __wbg_topologyblock_free: (a: number, b: number) => void;
+    readonly __wbg_transformerror_free: (a: number, b: number) => void;
     readonly __wbg_valenceerror_free: (a: number, b: number) => void;
     readonly __wbg_valenceparams_free: (a: number, b: number) => void;
     readonly __wbg_xyzreaderror_free: (a: number, b: number) => void;
@@ -2546,13 +3761,37 @@ export interface InitOutput {
     readonly addhsparams_explicitOnly: (a: number) => number;
     readonly addhsparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
     readonly addhsparams_onlyOnAtoms: (a: number) => any;
+    readonly addhsparams_set_addCoords: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_addResidueInfo: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_explicitOnly: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_onlyOnAtoms: (a: number, b: any) => [number, number];
+    readonly addhsparams_set_skipQueries: (a: number, b: any) => [number, number];
     readonly addhsparams_skipQueries: (a: number) => number;
     readonly aromaticityerror_cause: (a: number) => [number, number, number];
     readonly aromaticityerror_domain: (a: number) => [number, number];
     readonly aromaticityerror_kind: (a: number) => [number, number];
     readonly aromaticityerror_message: (a: number) => [number, number];
     readonly aromaticityparams_model: (a: number) => number;
-    readonly aromaticityparams_new: (a: number) => number;
+    readonly aromaticityparams_new: (a: any) => [number, number, number];
+    readonly aromaticityparams_set_model: (a: number, b: any) => [number, number];
+    readonly atom_atomMap: (a: number) => any;
+    readonly atom_atomicNumber: (a: number) => number;
+    readonly atom_chiralTag: (a: number) => number;
+    readonly atom_chiralTagCode: (a: number) => number;
+    readonly atom_chiralTagName: (a: number) => [number, number];
+    readonly atom_cipDescriptor: (a: number) => [number, number, number];
+    readonly atom_cipNeighborOrder: (a: number) => [number, number, number];
+    readonly atom_cipRank: (a: number) => [number, number, number];
+    readonly atom_element: (a: number) => [number, number, number];
+    readonly atom_explicitHydrogens: (a: number) => number;
+    readonly atom_formalCharge: (a: number) => number;
+    readonly atom_hybridization: (a: number) => number;
+    readonly atom_id: (a: number) => number;
+    readonly atom_isAromatic: (a: number) => number;
+    readonly atom_isotope: (a: number) => any;
+    readonly atom_noImplicit: (a: number) => number;
+    readonly atom_radicalElectrons: (a: number) => number;
+    readonly atom_templateAttachmentOrder: (a: number) => any;
     readonly atomcodeexplanation_branchCount: (a: number) => number;
     readonly atomcodeexplanation_chirality: (a: number) => any;
     readonly atomcodeexplanation_fromCode: (a: any, b: any, c: any) => [number, number, number];
@@ -2563,11 +3802,18 @@ export interface InitOutput {
     readonly atomcodeexplanationerror_domain: (a: number) => [number, number];
     readonly atomcodeexplanationerror_kind: (a: number) => [number, number];
     readonly atomcodeexplanationerror_message: (a: number) => [number, number];
+    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 atompairatomcoderesult_code: (a: number) => number;
     readonly atompairatomcoderesult_molecule: (a: number) => number;
     readonly atompairatominvariantsgenerator_includeChirality: (a: number) => number;
     readonly atompairatominvariantsgenerator_infoString: (a: number) => [number, number];
     readonly atompairatominvariantsgenerator_new: (a: any, b: any) => [number, number, number];
+    readonly atompairatominvariantsgenerator_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly atompairatominvariantsgenerator_set_topologicalTorsionCorrection: (a: number, b: any) => [number, number];
     readonly atompairatominvariantsgenerator_toJson: (a: number) => [number, number];
     readonly atompairatominvariantsgenerator_topologicalTorsionCorrection: (a: number) => number;
     readonly atompairfingerprintparams_atomInvariantsGenerator: (a: number) => any;
@@ -2578,6 +3824,14 @@ export interface InitOutput {
     readonly atompairfingerprintparams_generator: (a: number) => number;
     readonly atompairfingerprintparams_ignoreAtoms: (a: number) => any;
     readonly atompairfingerprintparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any) => [number, number, number];
+    readonly atompairfingerprintparams_set_atomInvariantsGenerator: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_customBondInvariants: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_generator: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
+    readonly atompairfingerprintparams_set_useLegacyStereoPerception: (a: number, b: any) => [number, number];
     readonly atompairfingerprintparams_useLegacyStereoPerception: (a: number) => number;
     readonly atompairparams_bitsPerFeature: (a: number) => number;
     readonly atompairparams_countBounds: (a: number) => any;
@@ -2588,6 +3842,14 @@ export interface InitOutput {
     readonly atompairparams_maxDistance: (a: number) => number;
     readonly atompairparams_minDistance: (a: number) => number;
     readonly atompairparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any) => [number, number, number];
+    readonly atompairparams_set_bitsPerFeature: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_countBounds: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_countSimulation: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_maxDistance: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_minDistance: (a: number, b: any) => [number, number];
+    readonly atompairparams_set_use2d: (a: number, b: any) => [number, number];
     readonly atompairparams_toJson: (a: number) => [number, number];
     readonly atompairparams_use2d: (a: number) => number;
     readonly atompairparams_withJson: (a: number, b: number, c: number) => [number, number, number];
@@ -2605,6 +3867,15 @@ export interface InitOutput {
     readonly atompairsparameters_numPiBits: () => number;
     readonly atompairsparameters_numTypeBits: () => number;
     readonly atompairsparameters_version: () => [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 avalonengineerror_domain: (a: number) => [number, number];
     readonly avalonengineerror_kind: (a: number) => [number, number];
     readonly avalonengineerror_reason: (a: number) => [number, number];
@@ -2633,6 +3904,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;
@@ -2652,12 +3927,18 @@ export interface InitOutput {
     readonly batchfingerprintoutputerror_message: (a: number) => [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;
@@ -2669,6 +3950,23 @@ export interface InitOutput {
     readonly batchvalidationerror_message: (a: number) => [number, number];
     readonly batchvalidationerror_reason: (a: number) => any;
     readonly batchvalidationerror_recordErrors: (a: number) => [number, number];
+    readonly bond_begin: (a: number) => number;
+    readonly bond_cipDescriptor: (a: number) => [number, number, number];
+    readonly bond_cipNeighborOrder: (a: number) => [number, number, number];
+    readonly bond_direction: (a: number) => number;
+    readonly bond_directionCode: (a: number) => number;
+    readonly bond_directionName: (a: number) => [number, number];
+    readonly bond_end: (a: number) => number;
+    readonly bond_id: (a: number) => number;
+    readonly bond_isAromatic: (a: number) => number;
+    readonly bond_order: (a: number) => number;
+    readonly bond_orderCode: (a: number) => number;
+    readonly bond_orderName: (a: number) => [number, number];
+    readonly bond_stereo: (a: number) => number;
+    readonly bond_stereoAtoms: (a: number) => any;
+    readonly bond_stereoCode: (a: number) => number;
+    readonly bond_stereoName: (a: number) => [number, number];
+    readonly bondspec_new: (a: any, b: any, c: any) => [number, number, number];
     readonly chemistryproblem_error: (a: number) => [number, number, number];
     readonly chemistryproblem_operation: (a: number) => number;
     readonly chemistryproblemerror_cause: (a: number) => any;
@@ -2676,6 +3974,21 @@ 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 ciprankerror_actual: (a: number) => any;
     readonly ciprankerror_atom: (a: number) => any;
     readonly ciprankerror_atomCount: (a: number) => any;
@@ -2695,8 +4008,68 @@ export interface InitOutput {
     readonly compiledquery_numAtoms: (a: number) => number;
     readonly compiledquery_numBonds: (a: number) => number;
     readonly compiledquery_query: (a: number) => number;
+    readonly conformer2d_coordinates: (a: number) => any;
+    readonly conformer2d_id: (a: number) => number;
+    readonly conformer2d_props: (a: number) => [number, number, number];
+    readonly conformer3d_coordinates: (a: number) => any;
+    readonly conformer3d_id: (a: number) => number;
+    readonly conformer3d_is3d: (a: number) => number;
+    readonly conformer3d_props: (a: number) => [number, number, number];
+    readonly coordinate2dinputparams_new: (a: any) => [number, number, number];
+    readonly coordinate2dinputparams_set_zPolicy: (a: number, b: any) => [number, number];
+    readonly coordinate2dinputparams_zPolicy: (a: number) => number;
+    readonly coordinate3dinputparams_is3d: (a: number) => number;
+    readonly coordinate3dinputparams_new: (a: any) => [number, number, number];
+    readonly coordinate3dinputparams_set_is3d: (a: number, b: any) => [number, number];
+    readonly coordinate3dreaderror_conformerId: (a: number) => number;
+    readonly coordinate3dreaderror_count: (a: number) => number;
+    readonly coordinate3dreaderror_domain: (a: number) => [number, number];
+    readonly coordinate3dreaderror_kind: (a: number) => [number, number];
+    readonly coordinate3dreaderror_message: (a: number) => [number, number];
+    readonly coordinateblock_conformers2d: (a: number) => any;
+    readonly coordinateblock_conformers3d: (a: number) => any;
+    readonly coordinateblock_sourceConformerOrder: (a: number) => any;
+    readonly coordinateblock_sourceCoordinateDim: (a: number) => any;
+    readonly coordinateinputerror_cause: (a: number) => [number, number, number];
+    readonly coordinateinputerror_domain: (a: number) => [number, number];
+    readonly coordinateinputerror_kind: (a: number) => [number, number];
+    readonly coordinateinputerror_message: (a: number) => [number, number];
+    readonly coordinatezpolicy_Error: () => number;
+    readonly coordinatezpolicy_Ignore: () => number;
+    readonly coordinatezpolicy_RequireZero: () => number;
+    readonly coordinatezpolicy_fromName: (a: number, b: number) => [number, number, number];
     readonly crippentotals_logp: (a: number) => number;
     readonly crippentotals_molarRefractivity: (a: 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];
@@ -2724,8 +4097,12 @@ export interface InitOutput {
     readonly descriptorreaderror_message: (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;
@@ -2742,9 +4119,15 @@ export interface InitOutput {
     readonly elementinfo_symbol: (a: number) => [number, number];
     readonly elementinfo_valences: (a: number) => [number, number];
     readonly explainPathScore: (a: any, b: any) => [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 fingerprintLayeredQueryWithOutputWithParams: (a: number, b: number) => [number, number, number];
     readonly fingerprintLayeredQueryWithParams: (a: number, b: number) => [number, number, number];
-    readonly fingerprintPatternQuery: (a: number) => [number, number, number];
+    readonly fingerprintPatternQuery: (a: number, b: any) => [number, number, number];
     readonly fingerprintPatternQueryWithParams: (a: number, b: number) => [number, number, number];
     readonly fingerprintTopologicalQueryWithOutputWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly fingerprintTopologicalQueryWithParams: (a: number, b: number) => [number, number, number];
@@ -2777,6 +4160,31 @@ export interface InitOutput {
     readonly fingerprintpreparationerror_domain: (a: number) => [number, number];
     readonly fingerprintpreparationerror_kind: (a: number) => [number, number];
     readonly fingerprintpreparationerror_message: (a: number) => [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];
@@ -2803,6 +4211,9 @@ 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 labuteasacontributions_asa: (a: number) => number;
     readonly labuteasacontributions_atomContributions: (a: number) => [number, number];
     readonly labuteasacontributions_hydrogenContribution: (a: number) => number;
@@ -2821,6 +4232,14 @@ export interface InitOutput {
     readonly layeredfingerprintparams_minPath: (a: number) => number;
     readonly layeredfingerprintparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any) => [number, number, number];
     readonly layeredfingerprintparams_setOnlyBits: (a: number) => any;
+    readonly layeredfingerprintparams_set_atomCounts: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_branchedPaths: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_layers: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_maxPath: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_minPath: (a: number, b: any) => [number, number];
+    readonly layeredfingerprintparams_set_setOnlyBits: (a: number, b: any) => [number, number];
     readonly layeredfingerprintresult_atomCounts: (a: number) => any;
     readonly layeredfingerprintresult_fingerprint: (a: number) => number;
     readonly legacytopologicaltorsionparams_bitsPerEntry: (a: number) => number;
@@ -2831,7 +4250,17 @@ export interface InitOutput {
     readonly legacytopologicaltorsionparams_ignoreAtoms: (a: number) => any;
     readonly legacytopologicaltorsionparams_includeChirality: (a: number) => number;
     readonly legacytopologicaltorsionparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
+    readonly legacytopologicaltorsionparams_set_bitsPerEntry: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly legacytopologicaltorsionparams_set_torsionAtomCount: (a: number, b: any) => [number, number];
     readonly legacytopologicaltorsionparams_torsionAtomCount: (a: number) => number;
+    readonly ligandref_atom: (a: number) => any;
+    readonly ligandref_isImplicitHydrogen: (a: number) => number;
+    readonly ligandref_new: (a: any) => [number, number, number];
     readonly maccsfingerprinterror_bit: (a: number) => any;
     readonly maccsfingerprinterror_cause: (a: number) => any;
     readonly maccsfingerprinterror_domain: (a: number) => [number, number];
@@ -2841,6 +4270,7 @@ export interface InitOutput {
     readonly maccsfingerprinterror_reason: (a: number) => any;
     readonly maccsfingerprintparams_nBits: (a: number) => number;
     readonly maccsfingerprintparams_new: (a: any) => [number, number, number];
+    readonly maccsfingerprintparams_set_nBits: (a: number, b: any) => [number, number];
     readonly matcherror_cause: (a: number) => [number, number, number];
     readonly matcherror_domain: (a: number) => [number, number];
     readonly matcherror_kind: (a: number) => [number, number];
@@ -2936,6 +4366,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;
@@ -2945,6 +4379,13 @@ export interface InitOutput {
     readonly molblockwriteparams_kekulize: (a: number) => number;
     readonly molblockwriteparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
     readonly molblockwriteparams_precision: (a: number) => number;
+    readonly molblockwriteparams_set_coordinateSelection: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_force2d: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_format: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_includeCoordinates: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_includeStereo: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_kekulize: (a: number, b: any) => [number, number];
+    readonly molblockwriteparams_set_precision: (a: number, b: any) => [number, number];
     readonly molcoordinateselection_Auto: () => number;
     readonly molcoordinateselection_ThreeD: (a: any) => [number, number, number];
     readonly molcoordinateselection_TwoD: (a: any) => [number, number, number];
@@ -2966,20 +4407,31 @@ 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_add3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_add3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_addHydrogens: (a: number, b: any) => [number, number];
     readonly molecule_addHydrogensWithParams: (a: number, b: any) => [number, number];
-    readonly molecule_assignAromaticity: (a: number) => [number, number];
+    readonly molecule_assignAromaticity: (a: number, b: any) => [number, number];
     readonly molecule_assignAromaticityWithParams: (a: number, b: number) => [number, number];
+    readonly molecule_assignChiralTagsFromStructure: (a: number, b: any) => [number, number];
+    readonly molecule_assignChiralTagsFromStructureWithParams: (a: number, b: number) => [number, number];
+    readonly molecule_assignCipLabels: (a: number, b: any) => [number, number];
+    readonly molecule_assignCipLabelsWithOptions: (a: number, b: number) => [number, number];
     readonly molecule_assignRadicals: (a: number) => [number, number];
-    readonly molecule_assignRingFamilies: (a: number) => [number, number];
+    readonly molecule_assignRingFamilies: (a: number, b: any) => [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_assignValence: (a: number, b: any) => [number, number];
     readonly molecule_assignValenceWithParams: (a: number, b: number) => [number, number];
+    readonly molecule_atom: (a: number, b: any) => [number, number, number];
+    readonly molecule_atomMetadata: (a: number, b: any) => [number, number, number, number];
     readonly molecule_atomProperty: (a: number, b: any, c: number, d: number) => [number, number, number];
     readonly molecule_atomPropertyString: (a: number, b: any, c: number, d: number) => [number, number, number];
     readonly molecule_atomicNumbers: (a: number) => [number, number];
+    readonly molecule_atoms: (a: number) => [number, number];
+    readonly molecule_bond: (a: number, b: any) => [number, number, number];
     readonly molecule_bondPropertyString: (a: number, b: any, c: number, d: number) => [number, number, number];
+    readonly molecule_bonds: (a: number) => [number, number];
     readonly molecule_chi0: (a: number) => [number, number, number];
     readonly molecule_chi0N: (a: number) => [number, number, number];
     readonly molecule_chi0NWithParams: (a: number, b: any) => [number, number, number];
@@ -3006,24 +4458,27 @@ export interface InitOutput {
     readonly molecule_chiNNWithParams: (a: number, b: any, c: any) => [number, number, number];
     readonly molecule_chiNV: (a: number, b: any) => [number, number, number];
     readonly molecule_chiNVWithParams: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_cipComputed: (a: number) => [number, number, number];
+    readonly molecule_clear3dConformers: (a: number) => [number, number];
+    readonly molecule_conformers3d: (a: number) => any;
     readonly molecule_coordinates2d: (a: number) => [number, number];
-    readonly molecule_coordinates3d: (a: number, b: number) => [number, number];
+    readonly molecule_coordinates3d: (a: number, b: any) => [number, number, number, number];
     readonly molecule_crippenDescriptors: (a: number) => [number, number, number];
     readonly molecule_crippenDescriptorsWithParams: (a: number, b: any, c: any) => [number, number, number];
-    readonly molecule_detectChemistryProblems: (a: number) => [number, number, number];
+    readonly molecule_detectChemistryProblems: (a: number, b: any) => [number, number, number];
     readonly molecule_detectChemistryProblemsWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_distanceMatrix: (a: number) => [number, number, number];
-    readonly molecule_distanceMatrix3d: (a: number) => [number, number, number];
+    readonly molecule_distanceMatrix: (a: number, b: any) => [number, number, number];
+    readonly molecule_distanceMatrix3d: (a: number, b: any) => [number, number, number];
     readonly molecule_distanceMatrix3dWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_distanceMatrixWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_exactMolecularWeight: (a: number) => [number, number, number];
     readonly molecule_exactMolecularWeightWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_findChiralCenters: (a: number, b: any) => [number, number, number];
-    readonly molecule_fingerprintAtomPair: (a: number) => [number, number, number];
-    readonly molecule_fingerprintAtomPairCount: (a: number) => [number, number, number];
+    readonly molecule_fingerprintAtomPair: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintAtomPairCount: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintAtomPairCountWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fingerprintAtomPairSparse: (a: number) => [number, number, number];
-    readonly molecule_fingerprintAtomPairSparseCount: (a: number) => [number, number, number];
+    readonly molecule_fingerprintAtomPairSparse: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintAtomPairSparseCount: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintAtomPairSparseCountWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fingerprintAtomPairSparseWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fingerprintAtomPairWithParams: (a: number, b: number, c: any) => [number, number, number];
@@ -3033,35 +4488,35 @@ export interface InitOutput {
     readonly molecule_fingerprintLayeredWithOutput: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintLayeredWithOutputWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_fingerprintLayeredWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_fingerprintMaccs: (a: number) => [number, number, number];
+    readonly molecule_fingerprintMaccs: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintMaccsRaw: (a: number) => [number, number, number];
     readonly molecule_fingerprintMaccsWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_fingerprintMorgan: (a: number) => [number, number, number];
-    readonly molecule_fingerprintMorganCount: (a: number) => [number, number, number];
+    readonly molecule_fingerprintMorgan: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintMorganCount: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintMorganCountWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintMorganCountWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fingerprintMorganSparse: (a: number) => [number, number, number];
-    readonly molecule_fingerprintMorganSparseCount: (a: number) => [number, number, number];
+    readonly molecule_fingerprintMorganSparse: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintMorganSparseCount: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintMorganSparseCountWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintMorganSparseCountWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fingerprintMorganSparseWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintMorganSparseWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fingerprintMorganWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintMorganWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fingerprintPattern: (a: number) => [number, number, number];
+    readonly molecule_fingerprintPattern: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintPatternWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_fingerprintTopological: (a: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsion: (a: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionCount: (a: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionCountLegacy: (a: number) => [number, number, number];
+    readonly molecule_fingerprintTopological: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsion: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionCount: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionCountLegacy: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionCountLegacyWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionCountWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionCountWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionLegacy: (a: number) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionLegacy: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionLegacyWithParams: (a: number, b: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionSparse: (a: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionSparseCount: (a: number) => [number, number, number];
-    readonly molecule_fingerprintTopologicalTorsionSparseCountLegacy: (a: number) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionSparse: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionSparseCount: (a: number, b: any) => [number, number, number];
+    readonly molecule_fingerprintTopologicalTorsionSparseCountLegacy: (a: number, b: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionSparseCountLegacyWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionSparseCountWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionSparseCountWithParams: (a: number, b: number, c: any) => [number, number, number];
@@ -3069,29 +4524,32 @@ export interface InitOutput {
     readonly molecule_fingerprintTopologicalTorsionSparseWithParams: (a: number, b: number, c: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionWithGenerator: (a: number, b: number, c: any, d: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalTorsionWithParams: (a: number, b: number, c: any) => [number, number, number];
-    readonly molecule_fingerprintTopologicalWithOutput: (a: number) => [number, number, number];
+    readonly molecule_fingerprintTopologicalWithOutput: (a: number, b: any, c: any) => [number, number, number];
     readonly molecule_fingerprintTopologicalWithOutputWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly molecule_fingerprintTopologicalWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_fractionCsp3: (a: number) => [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_hallKierAlpha: (a: number) => [number, number, number];
     readonly molecule_hallKierAlphaWithContributions: (a: number) => [number, number, number];
+    readonly molecule_has2dCoordinates: (a: number) => number;
     readonly molecule_hasSubstructMatch: (a: number, b: any, c: any) => [number, number, number];
     readonly molecule_hasSubstructMatchWithParams: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_hasValenceViolation: (a: number, b: any) => [number, number, number];
     readonly molecule_kappa1: (a: number) => [number, number, number];
     readonly molecule_kappa2: (a: number) => [number, number, number];
     readonly molecule_kappa3: (a: number) => [number, number, number];
-    readonly molecule_kekulizeBonds: (a: number) => [number, number];
+    readonly molecule_kekulizeBonds: (a: number, b: any) => [number, number];
     readonly molecule_kekulizeBondsWithParams: (a: number, b: any) => [number, number];
     readonly molecule_labuteAsa: (a: number) => [number, number, number];
     readonly molecule_labuteAsaContributions: (a: number) => [number, number, number];
@@ -3137,26 +4595,39 @@ export interface InitOutput {
     readonly molecule_numSaturatedRings: (a: number) => [number, number, number];
     readonly molecule_numSpiroAtoms: (a: number) => [number, number, number];
     readonly molecule_numUnspecifiedAtomStereoCenters: (a: number) => [number, number, number];
+    readonly molecule_perceiveStereochemistry: (a: number) => [number, number];
     readonly molecule_phi: (a: number) => [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_qed: (a: 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_removeHydrogens: (a: number, b: any) => [number, number];
     readonly molecule_removeHydrogensWithParams: (a: number, b: any) => [number, number];
-    readonly molecule_sanitize: (a: number) => [number, 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_set2dCoordinates: (a: number, b: any, c: any) => [number, number];
+    readonly molecule_set2dCoordinatesWithParams: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_set3dCoordinates: (a: number, b: any, c: any) => [number, number];
+    readonly molecule_set3dCoordinatesWithParams: (a: number, b: any, c: number) => [number, number];
+    readonly molecule_setAtomPosition: (a: number, b: any, c: any, d: any) => [number, number];
+    readonly molecule_setAtomPositionWithParams: (a: number, b: any, c: any, d: number) => [number, number];
     readonly molecule_setAtomProperty: (a: number, b: any, c: number, d: number, e: any) => [number, number];
+    readonly molecule_setOnly3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_setOnly3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
     readonly molecule_slogpVsa: (a: number) => [number, number, number, number];
     readonly molecule_slogpVsa1: (a: number) => [number, number, number];
     readonly molecule_slogpVsa10: (a: number) => [number, number, number];
@@ -3188,79 +4659,112 @@ export interface InitOutput {
     readonly molecule_substructMatches: (a: number, b: any, c: any) => [number, number, number, number];
     readonly molecule_substructMatchesCompiled: (a: number, b: any) => [number, number, number, number];
     readonly molecule_substructMatchesWithParams: (a: number, b: any, c: any) => [number, number, number, number];
-    readonly molecule_toMol: (a: number) => [number, number, number, number];
+    readonly molecule_tetrahedralStereo: (a: number) => [number, number, number];
+    readonly molecule_toBuilder: (a: number) => number;
+    readonly molecule_toCxSmarts: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_toCxSmartsWithParams: (a: number, b: number) => [number, number, 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_toSmarts: (a: number, b: any) => [number, number, number, number];
+    readonly molecule_toSmartsWithParams: (a: number, b: 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_topologicalTorsionIds: (a: number) => [number, number, number];
     readonly molecule_topologicalTorsionIdsWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_topologicalTorsionPathScore: (a: number, b: any, c: any, d: any) => [bigint, number, number];
+    readonly molecule_topology: (a: number) => number;
     readonly molecule_totalAtomCount: (a: number) => [number, number, number];
     readonly molecule_tpsa: (a: number) => [number, number, number];
     readonly molecule_tpsaWithParams: (a: number, b: any, c: any) => [number, number, number];
-    readonly molecule_withAssignedAromaticity: (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_with3dCoordinates: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_with3dCoordinatesWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_withAdded3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_withAdded3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
+    readonly molecule_withAssignedAromaticity: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedAromaticityWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_withAssignedRadicals: (a: number) => [number, number, number];
-    readonly molecule_withAssignedRingFamilies: (a: number) => [number, number, number];
+    readonly molecule_withAssignedRingFamilies: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedRingFamiliesWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedRings: (a: number) => [number, number, number];
-    readonly molecule_withAssignedValence: (a: number) => [number, number, number];
+    readonly molecule_withAssignedValence: (a: number, b: any) => [number, number, number];
     readonly molecule_withAssignedValenceWithParams: (a: number, b: number) => [number, number, number];
     readonly molecule_withAtomPairAtomCode: (a: number, b: any, c: any, d: any, e: any) => [number, number, number];
+    readonly molecule_withAtomPosition: (a: number, b: any, c: any, d: any) => [number, number, number];
+    readonly molecule_withAtomPositionWithParams: (a: number, b: any, c: any, d: number) => [number, number, number];
     readonly molecule_withAtomProperty: (a: number, b: any, c: number, d: number, e: any) => [number, number, number];
-    readonly molecule_withHydrogens: (a: number) => [number, number, number];
+    readonly molecule_withChiralTagsFromStructure: (a: number, b: any) => [number, number, number];
+    readonly molecule_withChiralTagsFromStructureWithParams: (a: number, b: number) => [number, number, number];
+    readonly molecule_withCipLabels: (a: number, b: any) => [number, number, number];
+    readonly molecule_withCipLabelsWithOptions: (a: number, b: number) => [number, number, number];
+    readonly molecule_withCleared3dConformers: (a: number) => [number, number, number];
+    readonly molecule_withHydrogens: (a: number, b: any) => [number, number, number];
     readonly molecule_withHydrogensWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_withKekulizedBonds: (a: number) => [number, number, number];
+    readonly molecule_withKekulizedBonds: (a: number, b: any) => [number, number, number];
     readonly molecule_withKekulizedBondsWithParams: (a: number, b: any) => [number, number, number];
     readonly molecule_withName: (a: number, b: number, c: number) => [number, number, number];
+    readonly molecule_withOnly3dConformer: (a: number, b: any, c: any) => [number, number, number];
+    readonly molecule_withOnly3dConformerWithParams: (a: number, b: any, c: number) => [number, number, number];
     readonly molecule_withProperty: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly molecule_withSdfDataField: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-    readonly molecule_withoutHydrogens: (a: number) => [number, number, number];
+    readonly molecule_withoutHydrogens: (a: number, b: any) => [number, number, number];
     readonly molecule_withoutHydrogensWithParams: (a: number, b: any) => [number, number, number];
-    readonly molecule_writeMol: (a: number, b: number, c: number) => [number, number];
+    readonly molecule_writeMol: (a: number, b: number, c: number, d: any) => [number, number];
     readonly molecule_writeMolWithParams: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly molecule_writeSdf: (a: number, b: number, c: number) => [number, number];
-    readonly molecule_writeSdfFiles: (a: number, b: number, c: number, d: any) => [number, number, number, number];
+    readonly molecule_writeSdf: (a: number, b: number, c: number, d: any) => [number, number];
+    readonly molecule_writeSdfFiles: (a: number, b: number, c: number, d: any, e: any) => [number, number, number, number];
     readonly molecule_writeSdfFilesWithParams: (a: number, b: number, c: number, d: any, e: any) => [number, number, number, number];
     readonly molecule_writeSdfWithParams: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly molecule_writeXyz: (a: number, b: number, c: number) => [number, number];
+    readonly molecule_writeXyz: (a: number, b: number, c: number, d: any) => [number, number];
     readonly molecule_writeXyzWithParams: (a: number, b: number, c: number, d: any) => [number, number];
     readonly moleculebatch_errorMode: (a: number) => number;
     readonly moleculebatch_errors: (a: number) => [number, number];
-    readonly moleculebatch_fingerprintAtomPairCountList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintAtomPairCountList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintAtomPairCountListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintAtomPairList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintAtomPairList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintAtomPairListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintAtomPairSparseBitsList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintAtomPairSparseBitsList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintAtomPairSparseBitsListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintAtomPairSparseCountList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintAtomPairSparseCountList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintAtomPairSparseCountListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintAtomPairWithOutputList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintAtomPairWithOutputList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintAtomPairWithOutputListWithParams: (a: number, b: number, c: any, d: number) => [number, number, number];
-    readonly moleculebatch_fingerprintLayeredList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintLayeredList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintLayeredListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintLayeredWithOutputList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintLayeredWithOutputList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintLayeredWithOutputListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintMorganList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintMorganList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintMorganListWithGeneratorParams: (a: number, b: number, c: any, d: any, e: number, f: number) => [number, number, number];
     readonly moleculebatch_fingerprintMorganListWithParams: (a: number, b: number, c: number) => [number, number, number];
-    readonly moleculebatch_fingerprintMorganWithOutputList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintMorganWithOutputList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintMorganWithOutputListWithGeneratorParams: (a: number, b: number, c: any, d: any, e: number, f: any, g: number) => [number, number, number];
     readonly moleculebatch_fingerprintMorganWithOutputListWithParams: (a: number, b: number, c: any, d: number) => [number, number, number];
-    readonly moleculebatch_fingerprintPatternList: (a: number) => [number, number, number];
+    readonly moleculebatch_fingerprintPatternList: (a: number, b: any, c: any) => [number, number, number];
     readonly moleculebatch_fingerprintPatternListWithParams: (a: number, b: number, c: number) => [number, number, number];
+    readonly moleculebatch_fingerprintTopologicalTorsionList: (a: number, b: any, c: any) => [number, number, number];
+    readonly moleculebatch_fingerprintTopologicalTorsionListWithParams: (a: number, b: number, c: number) => [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;
@@ -3269,35 +4773,77 @@ 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 moleculehasherror_actual: (a: number) => any;
     readonly moleculehasherror_atomCount: (a: number) => any;
     readonly moleculehasherror_cause: (a: number) => any;
     readonly moleculehasherror_domain: (a: number) => [number, number];
     readonly moleculehasherror_kind: (a: number) => [number, number];
     readonly moleculehasherror_message: (a: number) => [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];
@@ -3322,6 +4868,8 @@ export interface InitOutput {
     readonly morganbondinvariantsgenerator_construct: (a: any, b: any) => [number, number, number];
     readonly morganbondinvariantsgenerator_includeChirality: (a: number) => number;
     readonly morganbondinvariantsgenerator_new: (a: any, b: any) => [number, number, number];
+    readonly morganbondinvariantsgenerator_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly morganbondinvariantsgenerator_set_useBondTypes: (a: number, b: any) => [number, number];
     readonly morganbondinvariantsgenerator_useBondTypes: (a: number) => number;
     readonly morgancallparams_conformerId: (a: number) => number;
     readonly morgancallparams_construct: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
@@ -3330,6 +4878,11 @@ export interface InitOutput {
     readonly morgancallparams_fromAtoms: (a: number) => any;
     readonly morgancallparams_ignoreAtoms: (a: number) => any;
     readonly morgancallparams_new: (a: any, b: any, c: any, d: any, e: any) => [number, number, number];
+    readonly morgancallparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly morgancallparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly morgancallparams_set_customBondInvariants: (a: number, b: any) => [number, number];
+    readonly morgancallparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly morgancallparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
     readonly morganfingerprintgenerator_construct: (a: any, b: any, c: any) => [number, number, number];
     readonly morganfingerprintgenerator_counts: (a: number, b: any, c: any) => [number, number, number];
     readonly morganfingerprintgenerator_fingerprints: (a: number, b: any, c: any) => [number, number, number];
@@ -3348,6 +4901,13 @@ export interface InitOutput {
     readonly morganfingerprintparams_ignoreAtoms: (a: number) => any;
     readonly morganfingerprintparams_invariants: (a: number) => number;
     readonly morganfingerprintparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
+    readonly morganfingerprintparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_customBondInvariants: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_generator: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
+    readonly morganfingerprintparams_set_invariants: (a: number, b: any) => [number, number];
     readonly morganinvariants_connectivity: () => number;
     readonly morganinvariants_features: () => number;
     readonly morganparams_bitsPerFeature: (a: number) => number;
@@ -3361,6 +4921,16 @@ export interface InitOutput {
     readonly morganparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any, i: any, j: any) => [number, number, number];
     readonly morganparams_onlyNonzeroInvariants: (a: number) => number;
     readonly morganparams_radius: (a: number) => number;
+    readonly morganparams_set_bitsPerFeature: (a: number, b: any) => [number, number];
+    readonly morganparams_set_countBounds: (a: number, b: any) => [number, number];
+    readonly morganparams_set_countSimulation: (a: number, b: any) => [number, number];
+    readonly morganparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly morganparams_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly morganparams_set_includeRedundantEnvironments: (a: number, b: any) => [number, number];
+    readonly morganparams_set_includeRingMembership: (a: number, b: any) => [number, number];
+    readonly morganparams_set_onlyNonzeroInvariants: (a: number, b: any) => [number, number];
+    readonly morganparams_set_radius: (a: number, b: any) => [number, number];
+    readonly morganparams_set_useBondTypes: (a: number, b: any) => [number, number];
     readonly morganparams_toJson: (a: number) => [number, number];
     readonly morganparams_useBondTypes: (a: number) => number;
     readonly morganparams_withJson: (a: number, b: number, c: number) => [number, number, number];
@@ -3393,7 +4963,23 @@ export interface InitOutput {
     readonly morgansettings_set_includeRedundantEnvironments: (a: number, b: any) => [number, number];
     readonly morgansettings_set_onlyNonzeroInvariants: (a: number, b: any) => [number, number];
     readonly morgansettings_set_radius: (a: number, b: any) => [number, number];
-    readonly parseSmarts: (a: number, b: number) => [number, number, number];
+    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 parseSmarts: (a: number, b: number, c: any) => [number, number, number];
     readonly parseSmartsWithParams: (a: number, b: number, c: number) => [number, number, number];
     readonly patternfingerprinterror_cause: (a: number) => any;
     readonly patternfingerprinterror_domain: (a: number) => [number, number];
@@ -3401,7 +4987,33 @@ export interface InitOutput {
     readonly patternfingerprinterror_message: (a: number) => [number, number];
     readonly patternfingerprintparams_nBits: (a: number) => number;
     readonly patternfingerprintparams_new: (a: any, b: any) => [number, number, number];
+    readonly patternfingerprintparams_set_nBits: (a: number, b: any) => [number, number];
+    readonly patternfingerprintparams_set_tautomeric: (a: number, b: any) => [number, number];
     readonly patternfingerprintparams_tautomeric: (a: number) => number;
+    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;
@@ -3433,11 +5045,20 @@ export interface InitOutput {
     readonly querycompileerror_domain: (a: number) => [number, number];
     readonly querycompileerror_kind: (a: number) => [number, number];
     readonly querycompileerror_message: (a: number) => [number, number];
-    readonly querygraph_fromSmarts: (a: number, b: number) => [number, number, number];
+    readonly querygraph_fromSmarts: (a: number, b: number, c: any) => [number, number, number];
     readonly querygraph_fromSmartsWithParams: (a: number, b: number, c: number) => [number, number, number];
     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;
@@ -3454,11 +5075,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];
@@ -3488,6 +5134,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];
@@ -3495,10 +5142,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];
@@ -3515,23 +5162,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;
@@ -3541,9 +5199,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;
@@ -3556,7 +5214,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];
@@ -3585,6 +5243,13 @@ export interface InitOutput {
     readonly smartsparseparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
     readonly smartsparseparams_parseName: (a: number) => number;
     readonly smartsparseparams_replacements: (a: number) => [number, number, number];
+    readonly smartsparseparams_set_allowCxsmiles: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_debugParse: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_mergeHs: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_parseName: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_replacements: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_skipCleanup: (a: number, b: any) => [number, number];
+    readonly smartsparseparams_set_strictCxsmiles: (a: number, b: any) => [number, number];
     readonly smartsparseparams_skipCleanup: (a: number) => number;
     readonly smartsparseparams_strictCxsmiles: (a: number) => number;
     readonly smartswriteerror_cause: (a: number) => [number, number, number];
@@ -3596,6 +5261,10 @@ export interface InitOutput {
     readonly smartswriteparams_isomericSmiles: (a: number) => number;
     readonly smartswriteparams_new: (a: any, b: any, c: any, d: any) => [number, number, number];
     readonly smartswriteparams_rootedAtAtom: (a: number) => any;
+    readonly smartswriteparams_set_includeAtomMaps: (a: number, b: any) => [number, number];
+    readonly smartswriteparams_set_includeDativeBonds: (a: number, b: any) => [number, number];
+    readonly smartswriteparams_set_isomericSmiles: (a: number, b: any) => [number, number];
+    readonly smartswriteparams_set_rootedAtAtom: (a: number, b: any) => [number, number];
     readonly smileserror_cause: (a: number) => any;
     readonly smileserror_domain: (a: number) => [number, number];
     readonly smileserror_kind: (a: number) => [number, number];
@@ -3607,8 +5276,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];
@@ -3623,6 +5309,15 @@ 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 sparsebitfingerprint_nBits: (a: number) => number;
     readonly sparsebitfingerprint_onBits: (a: number) => any;
     readonly sparsecountfingerprint32_fuzzyAnd: (a: number, b: number) => [number, number, number];
@@ -3653,10 +5348,23 @@ export interface InitOutput {
     readonly sparsecountfingerprint_withMultipliedScalar: (a: number, b: any) => [number, number, number];
     readonly sparsecountfingerprint_withSubtracted: (a: number, b: number) => [number, number, number];
     readonly sparsecountfingerprint_withSubtractedScalar: (a: number, b: any) => [number, 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;
@@ -3691,21 +5399,62 @@ export interface InitOutput {
     readonly substructmatcherror_rdkitFunction: (a: number) => any;
     readonly substructmatchparams_aromaticMatchesConjugated: (a: number) => number;
     readonly substructmatchparams_aromaticMatchesSingleOrDouble: (a: number) => number;
+    readonly substructmatchparams_atomMatch: (a: number) => any;
     readonly substructmatchparams_atomProperties: (a: number) => any;
+    readonly substructmatchparams_bondMatch: (a: number) => any;
     readonly substructmatchparams_bondProperties: (a: number) => any;
     readonly substructmatchparams_extraAtomCheckOverridesDefaultCheck: (a: number) => number;
     readonly substructmatchparams_extraBondCheckOverridesDefaultCheck: (a: number) => number;
+    readonly substructmatchparams_finalMatch: (a: number) => any;
     readonly substructmatchparams_maxMatches: (a: number) => number;
     readonly substructmatchparams_maxRecursiveMatches: (a: number) => number;
-    readonly substructmatchparams_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) => [number, number, number];
+    readonly substructmatchparams_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, r: any, s: any) => [number, number, number];
     readonly substructmatchparams_numThreads: (a: number) => number;
     readonly substructmatchparams_recursionPossible: (a: number) => number;
+    readonly substructmatchparams_set_aromaticMatchesConjugated: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_aromaticMatchesSingleOrDouble: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_atomMatch: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_atomProperties: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_bondMatch: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_bondProperties: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_extraAtomCheckOverridesDefaultCheck: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_extraBondCheckOverridesDefaultCheck: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_finalMatch: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_maxMatches: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_maxRecursiveMatches: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_numThreads: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_recursionPossible: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_specifiedStereoQueryMatchesUnspecified: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_uniquify: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_useChirality: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_useEnhancedStereo: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_useGenericMatchers: (a: number, b: any) => [number, number];
+    readonly substructmatchparams_set_useQueryQueryMatches: (a: number, b: any) => [number, number];
     readonly substructmatchparams_specifiedStereoQueryMatchesUnspecified: (a: number) => number;
     readonly substructmatchparams_uniquify: (a: number) => number;
     readonly substructmatchparams_useChirality: (a: number) => number;
     readonly substructmatchparams_useEnhancedStereo: (a: number) => number;
     readonly substructmatchparams_useGenericMatchers: (a: number) => number;
     readonly substructmatchparams_useQueryQueryMatches: (a: 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 topologicalfingerprinterror_cause: (a: number) => any;
     readonly topologicalfingerprinterror_domain: (a: number) => [number, number];
     readonly topologicalfingerprinterror_field: (a: number) => any;
@@ -3717,6 +5466,8 @@ export interface InitOutput {
     readonly topologicalfingerprintoutputrequest_atomBits: (a: number) => number;
     readonly topologicalfingerprintoutputrequest_bitInfo: (a: number) => number;
     readonly topologicalfingerprintoutputrequest_new: (a: any, b: any) => [number, number, number];
+    readonly topologicalfingerprintoutputrequest_set_atomBits: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintoutputrequest_set_bitInfo: (a: number, b: any) => [number, number];
     readonly topologicalfingerprintparams_atomInvariants: (a: number) => any;
     readonly topologicalfingerprintparams_branchedPaths: (a: number) => number;
     readonly topologicalfingerprintparams_fpSize: (a: number) => number;
@@ -3726,6 +5477,17 @@ export interface InitOutput {
     readonly topologicalfingerprintparams_minSize: (a: number) => number;
     readonly topologicalfingerprintparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any, i: any, j: any, k: any) => [number, number, number];
     readonly topologicalfingerprintparams_numBitsPerFeature: (a: number) => number;
+    readonly topologicalfingerprintparams_set_atomInvariants: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_branchedPaths: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_maxPath: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_minPath: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_minSize: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_numBitsPerFeature: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_targetDensity: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_useBondOrder: (a: number, b: any) => [number, number];
+    readonly topologicalfingerprintparams_set_useHs: (a: number, b: any) => [number, number];
     readonly topologicalfingerprintparams_targetDensity: (a: number) => number;
     readonly topologicalfingerprintparams_useBondOrder: (a: number) => number;
     readonly topologicalfingerprintparams_useHs: (a: number) => number;
@@ -3738,6 +5500,12 @@ export interface InitOutput {
     readonly topologicaltorsioncallparams_customBondInvariants: (a: number) => any;
     readonly topologicaltorsioncallparams_fromAtoms: (a: number) => any;
     readonly topologicaltorsioncallparams_ignoreAtoms: (a: number) => any;
+    readonly topologicaltorsioncallparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly topologicaltorsioncallparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly topologicaltorsioncallparams_set_customBondInvariants: (a: number, b: any) => [number, number];
+    readonly topologicaltorsioncallparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly topologicaltorsioncallparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
+    readonly topologicaltorsioncallparams_set_useLegacyStereoPerception: (a: number, b: any) => [number, number];
     readonly topologicaltorsioncallparams_useLegacyStereoPerception: (a: number) => number;
     readonly topologicaltorsionfingerprintgenerator_construct: (a: any, b: any) => [number, number, number];
     readonly topologicaltorsionfingerprintgenerator_counts: (a: number, b: any, c: any) => [number, number, number];
@@ -3757,6 +5525,14 @@ export interface InitOutput {
     readonly topologicaltorsionfingerprintparams_generator: (a: number) => number;
     readonly topologicaltorsionfingerprintparams_ignoreAtoms: (a: number) => any;
     readonly topologicaltorsionfingerprintparams_new: (a: any, b: any, c: any, d: any, e: any, f: any, g: any, h: any) => [number, number, number];
+    readonly topologicaltorsionfingerprintparams_set_atomInvariantsGenerator: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_conformerId: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_customAtomInvariants: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_customBondInvariants: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_fromAtoms: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_generator: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_ignoreAtoms: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionfingerprintparams_set_useLegacyStereoPerception: (a: number, b: any) => [number, number];
     readonly topologicaltorsionfingerprintparams_useLegacyStereoPerception: (a: number) => number;
     readonly topologicaltorsionparams_bitsPerFeature: (a: number) => number;
     readonly topologicaltorsionparams_construct: (a: any, b: any, c: any, d: any, e: any, f: any, g: any) => [number, number, number];
@@ -3766,6 +5542,13 @@ export interface InitOutput {
     readonly topologicaltorsionparams_includeChirality: (a: number) => number;
     readonly topologicaltorsionparams_infoString: (a: number) => [number, number];
     readonly topologicaltorsionparams_onlyShortestPaths: (a: number) => number;
+    readonly topologicaltorsionparams_set_bitsPerFeature: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_countBounds: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_countSimulation: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_fpSize: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_includeChirality: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_onlyShortestPaths: (a: number, b: any) => [number, number];
+    readonly topologicaltorsionparams_set_torsionAtomCount: (a: number, b: any) => [number, number];
     readonly topologicaltorsionparams_toJson: (a: number) => [number, number];
     readonly topologicaltorsionparams_torsionAtomCount: (a: number) => number;
     readonly topologicaltorsionparams_withJson: (a: number, b: number, c: number) => [number, number, number];
@@ -3805,6 +5588,14 @@ export interface InitOutput {
     readonly topologicaltorsionsettings_set_onlyShortestPaths: (a: number, b: any) => [number, number];
     readonly topologicaltorsionsettings_set_torsionAtomCount: (a: number, b: any) => [number, number];
     readonly topologicaltorsionsettings_torsionAtomCount: (a: number) => [number, number, number];
+    readonly topologyblock_atoms: (a: number) => any;
+    readonly topologyblock_bonds: (a: number) => any;
+    readonly topologyblock_stereoGroups: (a: number) => any;
+    readonly topologyblock_substanceGroups: (a: number) => any;
+    readonly transformerror_cause: (a: number) => [number, number, number];
+    readonly transformerror_domain: (a: number) => [number, number];
+    readonly transformerror_kind: (a: number) => [number, number];
+    readonly transformerror_message: (a: number) => [number, number];
     readonly valenceerror_atom: (a: number) => [number, number, number];
     readonly valenceerror_atomCount: (a: number) => [number, number, number];
     readonly valenceerror_atomicNumber: (a: number) => [number, number, number];
@@ -3831,6 +5622,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 writeCxSmarts: (a: any, b: any) => [number, number, number, number];
@@ -3849,48 +5642,90 @@ 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__h06d8947d24cdb09a: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h297733c6d7fd13b6: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h29c20ce8538a9d1b: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h29c20ce8538a9d1b_1151: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h29c20ce8538a9d1b_1186: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h29c20ce8538a9d1b_1269: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h29c20ce8538a9d1b_1305: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h397dcc0cef05b757: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h3a318fb900928b1c: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b_1028: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b_1141: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b_1268: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b_820: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h472adef07f51279b_974: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h47b66dda20fecfe8: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h47b66dda20fecfe8_1284: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h47b66dda20fecfe8_885: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h4b42559a3b70d069: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h584f144b867a9457: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h58b095ce6094a220: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h58b095ce6094a220_1260: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h5f3f09f66194bbb4: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h5fafa550188057b5: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h698691030e3396f8: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6993464745d45385: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6d48ee5edfc0bdd5: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6d48ee5edfc0bdd5_1088: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6d48ee5edfc0bdd5_1089: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h6d4daff84fb4529a: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h76f4a7b1e8aa4da1: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h7e5482ea7b517866: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__h7f4fc0a796d6b9f2: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__ha8691f344355b1fe: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hc01394d13b9159a1: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hc4634be700193f51: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__hd654dd69dd86e2fe: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__he7050d0fcd2b21a1: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__he7050d0fcd2b21a1_819: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__heb404c84584b6c9f: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__heb8f050f9d9c95c5: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__convert__closures________invoke__heefa0db33bbfaae2: (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__h0119d111347712fb: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_1347: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_1348: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_1631: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_1830: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_708: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0119d111347712fb_799: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0755900259906b26: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h0758fb54137c3da1: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h09249bc1e33bf636: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h16255e5444ac6fd7: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1bfd4a33dff3a7d3: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h1c92caff7acd310c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_1049: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_1349: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_1379: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_1800: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_709: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2ba5f0b515e74bef_800: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2c5cdcaf9ecb14d9: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2c5cdcaf9ecb14d9_1594: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h2c5cdcaf9ecb14d9_1595: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h30de2469a1573805: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h313e808bf579050d: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3a07b7790d0dab28: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3a07b7790d0dab28_1196: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3e3c897e6e30642f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3e3c897e6e30642f_1204: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3e3c897e6e30642f_1217: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3e3c897e6e30642f_710: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3e3c897e6e30642f_711: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1244: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1449: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1503: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1650: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1651: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1809: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_1811: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_601: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h3fd974c2de352ba3_961: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1661: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1696: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1698: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1808: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1810: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1856: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_1859: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h42555d3810d32846_483: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h4f95a2df47a16944: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h576573dc0a231b17: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h576573dc0a231b17_1243: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h594cf18f75f96704: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h5adfeddedbc698a9: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h5cc131b1726837b2: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h5ffd7c6335351b7a: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h677411a564b39505: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h6f27f52eaaaa84e7: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h7119713d4317d717: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h71cfffc567ddcf1e: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h838a43ddf3f95111: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h87713fb0728926f6: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h8820171d67c63a42: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h8d4bff015c72dced: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h9b8f65fef3671550: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h9b8f65fef3671550_1857: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__h9b8f65fef3671550_1858: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__ha6722a3dec2a6289: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hc1bc48614b4bd9f4: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hc9effd77fb63ce9f: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hce3e088eb8ff7817: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd5d8bbcab15ffecb: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd7aa8d8ad5f4e473: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hd98ae6622150137c: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hde947f8fae7b43c5: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hf3597466d120c7f4: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hf594920ae3c3d3d4: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hf75cb846bd1ed9e9: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hf9135a8318d544a3: (a: number, b: number, c: number) => void;
+    readonly wasm_bindgen__convert__closures________invoke__hfd4b6b6a3dfad278: (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;
@@ -3923,3 +5758,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;